OVM Compile dump (#120)

* Linted files

* Revert back to old artifacts structure

* Fixed conflict with smock

* fix dump, add ETH

* lint

* add janky find and replace

* lint
Co-authored-by: Kelvin Fichter <kelvinfichter@gmail.com>

packages/contracts/contracts/optimistic-ethereum/OVM/precompiles/OVM_ETH.sol

+// SPDX-License-Identifier: MIT
+// +build ovm
+pragma solidity >0.6.0 <0.8.0;
+
+/* Interface Imports */
+import { iOVM_ERC20 } from "../../iOVM/precompiles/iOVM_ERC20.sol";
+
+/**
+ * @title OVM_ETH
+ * @dev L2 CONTRACT (COMPILED)
+ */
+contract OVM_ETH is iOVM_ERC20 {
+
+    uint256 constant private MAX_UINT256 = 2**256 - 1;
+    mapping (address => uint256) public balances;
+    mapping (address => mapping (address => uint256)) public allowed;
+    /*
+    NOTE:
+    The following variables are OPTIONAL vanities. One does not have to include them.
+    They allow one to customise the token contract & in no way influences the core functionality.
+    Some wallets/interfaces might not even bother to look at this information.
+    */
+    string public name;                   //fancy name: eg OVM Coin
+    uint8 public decimals;                //How many decimals to show.
+    string public symbol;                 //An identifier: eg OVM
+    uint256 public override totalSupply;
+
+    constructor(
+        uint256 _initialAmount,
+        string memory _tokenName,
+        uint8 _decimalUnits,
+        string memory _tokenSymbol
+    ) public {
+        balances[msg.sender] = _initialAmount;               // Give the creator all initial tokens
+        totalSupply = _initialAmount;                        // Update total supply
+        name = _tokenName;                                   // Set the name for display purposes
+        decimals = _decimalUnits;                            // Amount of decimals for display purposes
+        symbol = _tokenSymbol;                               // Set the symbol for display purposes
+    }
+
+    function transfer(address _to, uint256 _value) external override returns (bool success) {
+        require(balances[msg.sender] >= _value);
+        balances[msg.sender] -= _value;
+        balances[_to] += _value;
+        emit Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) external override returns (bool success) {
+        uint256 allowance = allowed[_from][msg.sender];
+        require(balances[_from] >= _value && allowance >= _value);
+        balances[_to] += _value;
+        balances[_from] -= _value;
+        if (allowance < MAX_UINT256) {
+            allowed[_from][msg.sender] -= _value;
+        }
+        emit Transfer(_from, _to, _value);
+        return true;
+    }
+
+    function balanceOf(address _owner) external view override returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) external override returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) external view override returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+}
\ No newline at end of file

packages/contracts/contracts/optimistic-ethereum/OVM/precompiles/OVM_L2ToL1MessagePasser.sol

 // SPDX-License-Identifier: MIT
+// +build ovm
 pragma solidity >0.6.0 <0.8.0;
 
 /* Interface Imports */
 import { iOVM_L2ToL1MessagePasser } from "../../iOVM/precompiles/iOVM_L2ToL1MessagePasser.sol";
-import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
 
 /**
  * @title OVM_L2ToL1MessagePasser

packages/contracts/contracts/optimistic-ethereum/iOVM/precompiles/iOVM_ERC20.sol

+// SPDX-License-Identifier: MIT
+// +build ovm
+pragma solidity >0.6.0 <0.8.0;
+
+/**
+ * @title iOVM_ERC20
+ */
+interface iOVM_ERC20 {
+    /* This is a slight change to the ERC20 base standard.
+    function totalSupply() constant returns (uint256 supply);
+    is replaced with:
+    uint256 public totalSupply;
+    This automatically creates a getter function for the totalSupply.
+    This is moved to the base contract since public getter functions are not
+    currently recognised as an implementation of the matching abstract
+    function by the compiler.
+    */
+    /// total amount of tokens
+    function totalSupply() external view returns (uint256);
+
+    /// @param _owner The address from which the balance will be retrieved
+    /// @return balance The balance
+    function balanceOf(address _owner) external view returns (uint256 balance);
+
+    /// @notice send `_value` token to `_to` from `msg.sender`
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return success Whether the transfer was successful or not
+    function transfer(address _to, uint256 _value) external returns (bool success);
+
+    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
+    /// @param _from The address of the sender
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return success Whether the transfer was successful or not
+    function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
+
+    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @param _value The amount of tokens to be approved for transfer
+    /// @return success Whether the approval was successful or not
+    function approve(address _spender, uint256 _value) external returns (bool success);
+
+    /// @param _owner The address of the account owning tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @return remaining Amount of remaining tokens allowed to spent
+    function allowance(address _owner, address _spender) external view returns (uint256 remaining);
+
+    // solhint-disable-next-line no-simple-event-func-name
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
\ No newline at end of file

packages/contracts/src/contract-deployment/config.ts

@@ -25,6 +25,9 @@ export interface RollupDeployConfig {
     fraudProofWindowSeconds: number
     sequencerPublishWindowSeconds: number
   }
+  ethConfig: {
+    initialAmount: number
+  }
   whitelistConfig: {
     owner: string | Signer
     allowArbitraryContractDeployment: boolean
@@ -162,5 +165,9 @@ export const makeContractDeployConfig = async (
     OVM_BondManager: {
       factory: getContractFactory('mockOVM_BondManager'),
     },
+    OVM_ETH: {
+      factory: getContractFactory('OVM_ETH'),
+      params: [config.ethConfig.initialAmount, 'Ether', 18, 'ETH'],
+    },
   }
 }

packages/contracts/src/contract-dumps.ts

@@ -133,6 +133,9 @@ export const makeStateDump = async (): Promise<any> => {
       owner: signer,
       allowArbitraryContractDeployment: true,
     },
+    ethConfig: {
+      initialAmount: 0,
+    },
     dependencies: [
       'Lib_AddressManager',
       'OVM_DeployerWhitelist',
@@ -146,6 +149,7 @@ export const makeStateDump = async (): Promise<any> => {
       'OVM_SafetyChecker',
       'OVM_ExecutionManager',
       'OVM_StateManager',
+      'OVM_ETH',
       'mockOVM_ECDSAContractAccount',
     ],
   }
@@ -157,11 +161,18 @@ export const makeStateDump = async (): Promise<any> => {
     OVM_ECDSAContractAccount: '0x4200000000000000000000000000000000000003',
     OVM_ProxySequencerEntrypoint: '0x4200000000000000000000000000000000000004',
     OVM_SequencerEntrypoint: '0x4200000000000000000000000000000000000005',
-    //L2 ETH at 0x4200000000000000000000000000000000000006
+    OVM_ETH: '0x4200000000000000000000000000000000000006',
     OVM_L2CrossDomainMessenger: '0x4200000000000000000000000000000000000007',
     Lib_AddressManager: '0x4200000000000000000000000000000000000008',
   }
 
+  const ovmCompiled = [
+    'OVM_L2ToL1MessagePasser',
+    'OVM_L2CrossDomainMessenger',
+    'Lib_AddressManager',
+    'OVM_ETH',
+  ]
+
   const deploymentResult = await deploy(config)
   deploymentResult.contracts['Lib_AddressManager'] =
     deploymentResult.AddressManager
@@ -182,11 +193,24 @@ export const makeStateDump = async (): Promise<any> => {
   for (let i = 0; i < Object.keys(deploymentResult.contracts).length; i++) {
     const name = Object.keys(deploymentResult.contracts)[i]
     const contract = deploymentResult.contracts[name]
-
-    const codeBuf = await pStateManager.getContractCode(
-      fromHexString(contract.address)
-    )
-    const code = toHexString(codeBuf)
+    let code
+    if (ovmCompiled.includes(name)) {
+      const ovmDeployedBytecode = getContractDefinition(name, true)
+        .deployedBytecode
+      // TODO remove: deployedBytecode is missing the find and replace in solidity
+      code = ovmDeployedBytecode
+        .split(
+          '336000905af158601d01573d60011458600c01573d6000803e3d621234565260ea61109c52'
+        )
+        .join(
+          '336000905af158600e01573d6000803e3d6000fd5b3d6001141558600a015760016000f35b'
+        )
+    } else {
+      const codeBuf = await pStateManager.getContractCode(
+        fromHexString(contract.address)
+      )
+      code = toHexString(codeBuf)
+    }
 
     const deadAddress =
       precompiles[name] ||