Add Optimism L2 bridge contracts

- Add Optimism L2 bridge contracts
- Add Optimism specific OVM_EOACodeHashSet contract
- Add ERC677Receiver functionality to L1/L2 gateways
- Add L1-L2 deposit-withdraw bridge integration tests
- Force compile OZ TransparentUpgradeableProxy.sol & ProxyAdmin.sol

Author: krebernisak

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ### Added
 
+- Optimism L2 bridge support
 - Access controlled mintable & burnable LinkToken, for use on sidechains and L2 networks.
 
 ### Changed

contracts/v0.7/bridge/README.md

@@ -1,3 +1,15 @@
 # LINK Token Bridge v0.7
 
 - `./token/LinkTokenChild.sol`: A mintable & burnable child LinkToken contract to be used on child networks.
+
+## Optimism L2 bridge
+
+The Optimistic Virtual Machine (OVM) is a scalable form of the EVM. Optimistic Rollup, by [Optimism](https://optimism.io), is the core scaling solution which enables the off-chain OVM to achieve cheap, instant transactions that still inherit L1 security. The OVM is an EVM-based VM which supports optimistically executing EVM smart contracts on a layer 1 blockchain like Ethereum. It is structured in such a way that it is possible to verify individual steps of its computation on Ethereum mainnet. This allows the mainnet to enforce validity of state roots with fraud proofs in the layer 2 Optimistic Rollup chain. For more information consult the [Optimism developer documentation](https://community.optimism.io/docs/).
+
+The set of contracts needed for the Optimism L2 LinkToken bridge can be found in the [./optimism](./optimism) dir.
+
+- `./optimism/OVM_EOACodeHashSet.sol`: Abstract helper contract used to keep track of OVM EOA contract set (OVM specific)
+- `./optimism/OVM_L1ERC20Gateway.sol`: Contract which stores deposited L1 funds that are in use on L2, and unlocks/transfers L1 funds on withdrawal. It synchronizes a corresponding L2 ERC20 Gateway, informing it of deposits, and listening to it for newly finalized withdrawals. (delegate proxy deployment)
+- `./optimism/OVM_L2ERC20Gateway.sol`: Contract which mints deposited L2 funds that are locked on L1, and burns L2 funds on withdrawal. It synchronizes a corresponding L1 ERC20 Gateway, informing it of withdrawals, and listening to it for newly finalized deposits. (delegate proxy deployment)
+
+These contracts are an implementation of [abstracts bridge contracts provided by Optimism](https://github.com/ethereum-optimism/optimism/tree/master/packages/contracts/contracts/optimistic-ethereum/OVM/bridge/tokens).

contracts/v0.7/bridge/mocks/ERC677CallerMock.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >0.6.0 <0.8.0;
+
+/* Interface Imports */
+import { ERC677 } from "../../../v0.6/token/ERC677.sol";
+
+contract ERC677CallerMock {
+  /// @dev Forward transferAndCall to destination contract
+  function callTransferAndCall(
+    address destintion,
+    address to,
+    uint value,
+    bytes memory data
+  )
+    external
+  {
+    ERC677(destintion).transferAndCall(to, value, data);
+  }
+}

contracts/v0.7/bridge/optimism/OVM_EOACodeHashSet.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >0.6.0 <0.8.0;
+
+/* Library Imports */
+import { EnumerableSet } from "@openzeppelin/contracts/utils/EnumerableSet.sol";
+
+/* Contract Imports */
+import { Initializable } from "@openzeppelin/contracts/proxy/Initializable.sol";
+import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+/**
+ * @dev Abstract 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.
+ */
+abstract contract OVM_EOACodeHashSet is /* Initializable, */ OwnableUpgradeable {
+  // 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;
+
+  function __OVM_EOACodeHashSet_init()
+    internal
+    initializer()
+  {
+      __Context_init_unchained();
+      __Ownable_init_unchained();
+      __OVM_EOACodeHashSet_init_unchained();
+  }
+
+  /// @notice Adds genesis OVM_ProxyEOA.sol EXTCODEHASH to the default set.
+  function __OVM_EOACodeHashSet_init_unchained()
+    internal
+    initializer()
+  {
+    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);
+  }
+
+  /// @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 true if `account` is a whitelisted EOA contract.
+   * @param account Address to check
+   */
+  function _isEOAContract(
+    address account
+  )
+    internal
+    view
+    returns (bool)
+  {
+    bytes32 codehash;
+    // solhint-disable-next-line no-inline-assembly
+    assembly { codehash := extcodehash(account) }
+    return s_codeHasheSet.contains(codehash);
+  }
+}