Add onlyEOAContract restriction to standard bridge withdrawals

packages/contracts/contracts/optimistic-ethereum/OVM/bridge/tokens/OVM_L2StandardBridge.sol

@@ -10,6 +10,7 @@ import { iOVM_L2ERC20Bridge } from "../../../iOVM/bridge/tokens/iOVM_L2ERC20Brid
 /* Library Imports */
 import { ERC165Checker } from "@openzeppelin/contracts/introspection/ERC165Checker.sol";
 import { OVM_CrossDomainEnabled } from "../../../libraries/bridge/OVM_CrossDomainEnabled.sol";
+import { OVM_EOACodeHashSet } from "../../../libraries/bridge/OVM_EOACodeHashSet.sol";
 import { Lib_PredeployAddresses } from "../../../libraries/constants/Lib_PredeployAddresses.sol";
 
 /* Contract Imports */
@@ -25,7 +26,7 @@ import { IL2StandardERC20 } from "../../../libraries/standards/IL2StandardERC20.
  * Compiler used: optimistic-solc
  * Runtime target: OVM
  */
-contract OVM_L2StandardBridge is iOVM_L2ERC20Bridge, OVM_CrossDomainEnabled {
+contract OVM_L2StandardBridge is iOVM_L2ERC20Bridge, OVM_EOACodeHashSet, OVM_CrossDomainEnabled {
 
     /********************************
      * External Contract References *
@@ -66,6 +67,7 @@ contract OVM_L2StandardBridge is iOVM_L2ERC20Bridge, OVM_CrossDomainEnabled {
         external
         override
         virtual
+        onlyEOAContract()
     {
         _initiateWithdrawal(
             _l2Token,

packages/contracts/contracts/optimistic-ethereum/libraries/bridge/OVM_EOACodeHashSet.sol

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >0.5.0 <0.8.0;
+
+/* External Imports */
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { EnumerableSet } from "@openzeppelin/contracts/utils/EnumerableSet.sol";
+
+/**
+ * @title OVM_EOACodeHashSet
+ * @dev Helper contract used to keep track of OVM EOA contract set (OVM specific)
+ *
+ * The OVM implements a basic form of account abstraction. In effect, this means
+ * that the only type of account is a smart contract (no EOAs), and all user wallets
+ * are in fact smart contract wallets. So to check for EOA, we need to actually check if
+ * the sender is an OVM_ProxyEOA contract, which gets deployed by the ovmCREATEEOA opcode.
+ *
+ * As the OVM_ProxyEOA.sol contract source could potentially change in the future (i.e., due to a fork),
+ * here we actually track a set of possible EOA proxy contracts.
+ *
+ * Compiler used: optimistic-solc
+ * Runtime target: OVM
+ */
+contract OVM_EOACodeHashSet is Ownable {
+    // Add the EnumerableSet library
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+
+    // Declare a Bytes32Set of code hashes
+    EnumerableSet.Bytes32Set private s_codeHasheSet;
+
+    // Declare the genesis OVM_ProxyEOA.sol EXTCODEHASH
+    bytes32 constant OVM_EOA_CODE_HASH_V0 = 0x93bb081a7dd92bde63b4d0aa9b8612352b2ec585176a80efc0a2a277ecfc010e;
+    bytes32 constant OVM_EOA_CODE_HASH_V1 = 0x8b4ea2cb36c232a7bab9d385b7054ff04752ec4c0fad5dc2ed4b1c18d982154c;
+    bytes32 constant OVM_EOA_CODE_HASH_V2 = 0xb6268ee2707994607682cc0e3b288cdd71acc63df8de0e6baa39a31a2b91d0ad;
+    bytes32 constant OVM_EOA_CODE_HASH_V3 = 0x93fae832274ff6aa942fa0c287fc0d8fe180f26b36c92e83d9be7e39309d3464;
+    // Optimism v0.3.0-rc
+    bytes32 constant OVM_EOA_CODE_HASH_V4 = 0xef2ab076db773ffc554c9f287134123439a5228e92f5b3194a28fec0a0afafe3;
+
+    constructor() {
+        s_codeHasheSet.add(OVM_EOA_CODE_HASH_V0);
+        s_codeHasheSet.add(OVM_EOA_CODE_HASH_V1);
+        s_codeHasheSet.add(OVM_EOA_CODE_HASH_V2);
+        s_codeHasheSet.add(OVM_EOA_CODE_HASH_V3);
+        s_codeHasheSet.add(OVM_EOA_CODE_HASH_V4);
+    }
+
+    /// @notice Reverts if called by anyone other than whitelisted EOA contracts.
+    modifier onlyEOAContract() {
+        require(_isEOAContract(msg.sender), "Only callable by whitelisted EOA");
+        _;
+    }
+
+    /**
+    * @dev Returns true if the EOA contract code hash value is in the set. O(1).
+    *
+    * @param value EOA contract code hash to check
+    */
+    function containsEOACodeHash(
+        bytes32 value
+    )
+        public
+        view
+        returns (bool)
+    {
+        return s_codeHasheSet.contains(value);
+    }
+
+    /**
+    * @dev Adds a EOA contract code hash value to the set. O(1).
+    *
+    * Returns true if the value was added to the set, that is if it was not already present.
+    * @param value EOA contract code hash to add
+    */
+    function addEOACodeHash(
+        bytes32 value
+    )
+        public
+        onlyOwner()
+        returns (bool)
+    {
+        return s_codeHasheSet.add(value);
+    }
+
+    /**
+    * @dev Removes a EOA contract code hash value from the set. O(1).
+    *
+    * Returns true if the value was removed from the set, that is if it was present.
+    * @param value EOA contract code hash to remove
+    */
+    function removeEOACodeHash(
+        bytes32 value
+    )
+        public
+        onlyOwner()
+        returns (bool)
+    {
+        return s_codeHasheSet.remove(value);
+    }
+
+    /**
+    * @dev Returns the codehash for `account`.
+    * @param account Address to get codehash for
+    */
+    function getCodeHash(
+        address account
+    )
+        public
+        view
+        returns (bytes32)
+    {
+        bytes32 codehash;
+
+        assembly { codehash := extcodehash(account) }
+
+        return codehash;
+    }
+
+    /**
+    * @dev Returns true if `account` is a whitelisted EOA contract.
+    * @param account Address to check
+    */
+    function _isEOAContract(
+        address account
+    )
+        internal
+        view
+        returns (bool)
+    {
+        bytes32 codehash;
+
+        assembly { codehash := extcodehash(account) }
+        return s_codeHasheSet.contains(codehash);
+    }
+}

packages/contracts/test/contracts/OVM/bridge/assets/OVM_L2StandardBridge.spec.ts

@@ -2,7 +2,7 @@ import { expect } from '../../../../setup'
 
 /* External Imports */
 import { ethers } from 'hardhat'
-import { Signer, ContractFactory, Contract } from 'ethers'
+import { Signer, ContractFactory, Contract, constants } from 'ethers'
 import { Interface } from 'ethers/lib/utils'
 import {
   smockit,
@@ -14,7 +14,7 @@ import {
 /* Internal Imports */
 import { NON_NULL_BYTES32, NON_ZERO_ADDRESS } from '../../../../helpers'
 
-import { getContractInterface } from '../../../../../src'
+import { getContractInterface, predeploys } from '../../../../../src'
 
 const ERR_INVALID_MESSENGER = 'OVM_XCHAIN: messenger contract unauthenticated'
 const ERR_INVALID_X_DOMAIN_MSG_SENDER =
@@ -111,7 +111,7 @@ describe('OVM_L2StandardBridge', () => {
 
     it('should initilise a withdrawal if the L2 token is not compliant', async () => {
       // Deploy a non compliant ERC20
-      let NonCompilantERC20 = await (
+      const NonCompilantERC20 = await (
         await ethers.getContractFactory(
           '@openzeppelin/contracts/token/ERC20/ERC20.sol:ERC20'
         )
@@ -215,7 +215,12 @@ describe('OVM_L2StandardBridge', () => {
     })
 
     it('withdraw() burns and sends the correct withdrawal message', async () => {
-      await OVM_L2StandardBridge.withdraw(
+      // whitelist Alice's EOA contract in the Bridge for withdraw
+      const codeHash = await OVM_L2StandardBridge.getCodeHash(aliceAddress)
+      await OVM_L2StandardBridge.addEOACodeHash(codeHash)
+
+      // call withdraw
+      await OVM_L2StandardBridge.connect(alice).withdraw(
         SmoddedL2Token.address,
         withdrawAmount,
         0,
@@ -259,6 +264,17 @@ describe('OVM_L2StandardBridge', () => {
       expect(withdrawalCallToMessenger._gasLimit).to.equal(0)
     })
 
+    it('withdraw() cannot be called by a non whitelisted EOA', async () => {
+      expect(
+        OVM_L2StandardBridge.connect(alice).withdraw(
+          SmoddedL2Token.address,
+          withdrawAmount,
+          0,
+          NON_NULL_BYTES32
+        )
+      ).to.be.revertedWith('Only callable by whitelisted EOA')
+    })
+
     it('withdrawTo() burns and sends the correct withdrawal message', async () => {
       await OVM_L2StandardBridge.withdrawTo(
         SmoddedL2Token.address,