Support EIP1271 signatures (#4193)

* Support EIP1271 signatures

* Add test

* Add spinner when processing signature

Author: FrederikBolding

src/features/SignAndVerifyMessage/VerifyMessage.tsx

@@ -1,11 +1,12 @@
 import { FunctionComponent, useEffect, useState } from 'react';
 
-import { Button } from '@mycrypto/ui';
 import { parse } from 'query-string';
 import { RouteComponentProps, withRouter } from 'react-router-dom';
 import styled from 'styled-components';
 
-import { InputField } from '@components';
+import { Button, InputField } from '@components';
+import { ProviderHandler } from '@services/EthService';
+import { selectDefaultNetwork, useSelector } from '@store';
 import { BREAK_POINTS, COLORS } from '@theme';
 import translate, { translateRaw } from '@translations';
 import { ISignedMessage } from '@types';
@@ -23,13 +24,7 @@ const Content = styled.div`
   align-items: center;
 `;
 
-interface VerifyButtonProps {
-  disabled?: boolean;
-}
-
-const VerifyButton = styled(Button)<VerifyButtonProps>`
-  ${(props) => props.disabled && 'opacity: 0.4;'}
-
+const VerifyButton = styled(Button)`
   @media (max-width: ${SCREEN_XS}) {
     width: 100%;
   }
@@ -61,18 +56,26 @@ const VerifyMessage: FunctionComponent<RouteComponentProps & Props> = ({ locatio
   const [message, setMessage] = useState('');
   const [error, setError] = useState<string | undefined>(undefined);
   const [signedMessage, setSignedMessage] = useState<ISignedMessage | null>(null);
+  const [loading, setLoading] = useState<boolean>(false);
+  const network = useSelector(selectDefaultNetwork);
+  const provider = new ProviderHandler(network);
 
   const handleClick = () => handleVerifySignedMessage();
 
-  const handleVerifySignedMessage = (json?: string, trySingleQuotes?: boolean): void => {
+  const handleVerifySignedMessage = async (
+    json?: string,
+    trySingleQuotes?: boolean
+  ): Promise<void> => {
     const rawMessage = json ?? message;
+    setLoading(true);
 
     try {
       const normalizedMessage = trySingleQuotes ? normalizeSingleQuotes(rawMessage) : rawMessage;
       const parsedSignature: ISignedMessage = normalizeJson(normalizedMessage);
 
       const isValid = verifySignedMessage(parsedSignature);
-      if (!isValid) {
+      const isValidEIP1271 = !isValid && (await provider.isValidEIP1271Signature(parsedSignature));
+      if (!isValid && !isValidEIP1271) {
         throw Error();
       }
 
@@ -85,6 +88,8 @@ const VerifyMessage: FunctionComponent<RouteComponentProps & Props> = ({ locatio
 
       setError(translateRaw('ERROR_38'));
       setSignedMessage(null);
+    } finally {
+      setLoading(false);
     }
   };
 
@@ -127,7 +132,7 @@ const VerifyMessage: FunctionComponent<RouteComponentProps & Props> = ({ locatio
         height="150px"
         inputError={error}
       />
-      <VerifyButton disabled={!message} onClick={handleClick}>
+      <VerifyButton disabled={!message} loading={loading} onClick={handleClick}>
         {translate('MSG_VERIFY')}
       </VerifyButton>
       {signedMessage && (

src/services/EthService/contracts/eip1271.ts

@@ -0,0 +1,3 @@
+export const EIP1271_ABI = [
+  'function isValidSignature(bytes32 _message, bytes _signature) public view returns (bool)'
+];

src/services/EthService/contracts/index.ts

@@ -8,3 +8,4 @@ export { UniDistributor } from './uniDistributor';
 export { AaveMigrator } from './aaveMigrator';
 export { AntMigrator } from './antMigrator';
 export { GolemV2Migration } from './golemV2Migration';
+export * from './eip1271';

src/services/EthService/network/providerHandler.test.ts

@@ -48,4 +48,61 @@ describe('ProviderHandler', () => {
       ).resolves.toBeUndefined();
     });
   });
+
+  describe('isValidEIP1271Signature', () => {
+    nock.disableNetConnect();
+
+    afterEach(() => {
+      nock.cleanAll();
+    });
+
+    it('checks whether a signature is valid using EIP1271', async () => {
+      const provider = new ProviderHandler(fNetworks[0]);
+
+      nock(/.*/)
+        .post(/.*/)
+        .reply(200, () => ({
+          id: 1,
+          jsonrpc: '2.0',
+          result: '0x1626ba7e00000000000000000000000000000000000000000000000000000000'
+        }));
+
+      await expect(
+        provider.isValidEIP1271Signature({
+          address: '0x14987eb8d2553B3dfBe7B72AC5e062392E044644',
+          msg: 'testing with argent',
+          sig:
+            '0x0fe68c13c9f7cf89c565bce2f4930bd5aa0adf406c4edf0205a794e10c085ee36293abb9469f243d6438cada470f843c3f5bb1d9778af8465bbb7221da8e28de1b',
+          version: '2'
+        })
+      ).resolves.toBe(true);
+    });
+
+    it('returns false in case of errors', async () => {
+      const provider = new ProviderHandler(fNetworks[0]);
+
+      nock(/.*/)
+        .post(/.*/)
+        .reply(200, () => ({
+          id: 1,
+          jsonrpc: '2.0',
+          error: {
+            code: 3,
+            message: 'execution reverted: TM: Invalid signer',
+            data:
+              '0x08c379a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000012544d3a20496e76616c6964207369676e65720000000000000000000000000000'
+          }
+        }));
+
+      await expect(
+        provider.isValidEIP1271Signature({
+          address: '0x14987eb8d2553B3dfBe7B72AC5e062392E044644',
+          msg: 'bla',
+          sig:
+            '0x0fe68c13c9f7cf89c565bce2f4930bd5aa0adf406c4edf0205a794e10c085ee36293abb9469f243d6438cada470f843c3f5bb1d9778af8465bbb7221da8e28de1b',
+          version: '2'
+        })
+      ).resolves.toBe(false);
+    });
+  });
 });

src/services/EthService/network/providerHandler.ts

@@ -1,6 +1,7 @@
 import { FeeData } from '@ethersproject/abstract-provider';
 import { BigNumber } from '@ethersproject/bignumber';
 import { Contract } from '@ethersproject/contracts';
+import { hashMessage } from '@ethersproject/hash';
 import {
   BaseProvider,
   Block,
@@ -15,10 +16,19 @@ import Resolution from '@unstoppabledomains/resolution';
 import { DEFAULT_ASSET_DECIMAL } from '@config';
 import { ERC20 } from '@services/EthService';
 import { erc20Abi } from '@services/EthService/contracts/erc20';
-import { Asset, ITxObject, ITxSigned, Network, TAddress, TokenInformation } from '@types';
+import {
+  Asset,
+  ISignedMessage,
+  ITxObject,
+  ITxSigned,
+  Network,
+  TAddress,
+  TokenInformation
+} from '@types';
 import { baseToConvertedUnit } from '@utils';
 import { FallbackProvider } from '@vendor';
 
+import { EIP1271_ABI } from '../contracts';
 import { EthersJS } from './ethersJsProvider';
 import { createCustomNodeProvider } from './helpers';
 
@@ -174,6 +184,20 @@ export class ProviderHandler {
     });
   }
 
+  public async isValidEIP1271Signature({ address, msg, sig }: ISignedMessage): Promise<boolean> {
+    return this.injectClient(async (client) => {
+      try {
+        const hash = hashMessage(msg);
+        const contract = new Contract(address, EIP1271_ABI, client);
+        const result = await contract.isValidSignature(hash, sig);
+
+        return result;
+      } catch (e) {
+        return false;
+      }
+    });
+  }
+
   public resolveENSName(name: string): Promise<string | null> {
     return this.injectClient((client) => {
       // Use Unstoppable if supported, otherwise is probably an ENS name