Experimental new version w/ comms

Author: smartcontracts

.gitignore

@@ -0,0 +1,6 @@
+# Packages
+node_modules/
+
+# Hardhat build outputs
+artifacts/
+cache/

README.md

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >0.6.0 <0.8.0;
+
+/**
+ * @title ERC20
+ * @dev A super simple ERC20 implementation!
+ */
+contract ERC20 {
+
+    /**********
+     * Events *
+     **********/
+
+    event Transfer(
+        address indexed _from,
+        address indexed _to,
+        uint256 _value
+    );
+
+    event Approval(
+        address indexed _owner,
+        address indexed _spender,
+        uint256 _value
+    );
+
+
+    /*************
+     * Variables *
+     *************/
+
+    mapping (address => uint256) public balances;
+    mapping (address => mapping (address => uint256)) public allowances;
+
+    // Some optional extra goodies.
+    uint256 public totalSupply;
+    string public name;
+
+
+    /***************
+     * Constructor *
+     ***************/
+
+    /**
+     * @param _initialSupply Initial maximum token supply.
+     * @param _name A name for our ERC20 (technically optional, but it's fun ok jeez).
+     */
+    constructor(
+        uint256 _initialSupply,
+        string memory _name
+    )
+        public
+    {
+        balances[msg.sender] = _initialSupply;
+        totalSupply = _initialSupply;
+        name = _name;
+    }
+
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * Checks the balance of an address.
+     * @param _owner Address to check a balance for.
+     * @return Balance of the address.
+     */
+    function balanceOf(
+        address _owner
+    )
+        external
+        view
+        returns (
+            uint256
+        )
+    {
+        return balances[_owner];
+    }
+
+    /**
+     * Transfers a balance from your account to someone else's account!
+     * @param _to Address to transfer a balance to.
+     * @param _amount Amount to transfer to the other account.
+     * @return true if the transfer was successful.
+     */
+    function transfer(
+        address _to,
+        uint256 _amount
+    )
+        external
+        returns (
+            bool
+        )
+    {
+        require(
+            balances[msg.sender] >= _amount,
+            "You don't have enough balance to make this transfer!"
+        );
+
+        balances[msg.sender] -= _amount;
+        balances[_to] += _amount;
+
+        emit Transfer(
+            msg.sender,
+            _to,
+            _amount
+        );
+
+        return true;
+    }
+
+    /**
+     * Transfers a balance from someone else's account to another account. You need an allowance
+     * from the sending account for this to work!
+     * @param _from Account to transfer a balance from.
+     * @param _to Account to transfer a balance to.
+     * @param _amount Amount to transfer to the other account.
+     * @return true if the transfer was successful.
+     */
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _amount
+    )
+        external
+        returns (
+            bool
+        )
+    {
+        require(
+            balances[_from] >= _amount,
+            "Can't transfer from the desired account because it doesn't have enough balance."
+        );
+
+        require(
+            allowances[_from][msg.sender] >= _amount,
+            "Can't transfer from the desired account because you don't have enough of an allowance."
+        );
+
+        balances[_to] += _amount;
+        balances[_from] -= _amount;
+
+        emit Transfer(
+            _from,
+            _to,
+            _amount
+        );
+
+        return true;
+    }
+
+    /**
+     * Approves an account to spend some amount from your account.
+     * @param _spender Account to approve a balance for.
+     * @param _amount Amount to allow the account to spend from your account.
+     * @return true if the allowance was successful.
+     */
+    function approve(
+        address _spender,
+        uint256 _amount
+    )
+        external
+        returns (
+            bool
+        )
+    {
+        allowances[msg.sender][_spender] = _amount;
+
+        emit Approval(
+            msg.sender,
+            _spender,
+            _amount
+        );
+
+        return true;
+    }
+
+    /**
+     * Checks how much a given account is allowed to spend from another given account.
+     * @param _owner Address of the account to check an allowance from.
+     * @param _spender Address of the account trying to spend from the owner.
+     * @return Allowance for the spender from the owner.
+     */
+    function allowance(
+        address _owner,
+        address _spender
+    )
+        external
+        view
+        returns (
+            uint256
+        )
+    {
+        return allowances[_owner][_spender];
+    }
+}

contracts/ERC20.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >0.6.0 <0.8.0;
+
+import { ERC20 } from "./ERC20.sol";
+import { Layer2Bridged } from "./Layer2Bridged.sol";
+
+contract ERC20Adapter is Layer2Bridged {
+    ERC20 erc20;
+
+    constructor(
+        ERC20 _erc20
+    )
+        public
+    {
+        erc20 = _erc20;
+    }
+
+    function deposit(
+        address _depositor,
+        uint256 _amount
+    )
+        public
+    {
+        // 1. Transfer the amount from the depositor to this contract.
+        erc20.transferFrom(
+            _depositor,
+            address(this),
+            _amount
+        );
+
+        // 2. Generate a contract call to be executed on Layer 2.
+        bytes memory message = abi.encodeWithSignature(
+            "mint(address,uint256)",
+            _depositor,
+            _amount
+        );
+
+        // 3. Send the message to our partner contract.
+        sendMessageViaBridge(
+            message,
+            8000000
+        );
+    }
+
+    function withdraw(
+        address _withdrawer,
+        uint256 _amount
+    )
+        public
+        onlyViaBridge
+    {
+        erc20.transfer(
+            _withdrawer,
+            _amount
+        );
+    }
+}

contracts/ERC20Adapter.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >0.6.0 <0.8.0;
+
+import { iOVM_BaseCrossDomainMessenger } from "@eth-optimism/contracts/build/contracts/iOVM/bridge/iOVM_BaseCrossDomainMessenger.sol";
+
+contract Layer2Bridged {
+    address internal owner;
+    address internal partner;
+    address internal bridge;
+
+    constructor()
+        public
+    {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner() {
+        require(
+            msg.sender == owner,
+            "Layer2Bridged: Function can only be called by the contract owner."
+        );
+        _;
+    }
+
+    modifier onlyViaBridge() {
+        require(
+            msg.sender == bridge,
+            "Layer2Bridged: Function can only be called by the bridge contract."
+        );
+
+        require(
+            iOVM_BaseCrossDomainMessenger(
+                bridge
+            ).xDomainMessageSender() == partner,
+            "Layer2Bridged: Function can only be triggered by the partner contract."
+        );
+
+        _;
+    }
+
+    function createBridge(
+        address _partner,
+        address _bridge
+    )
+        public
+        onlyOwner
+    {
+        partner = _partner;
+        bridge = _bridge;
+    }
+
+    function sendMessageViaBridge(
+        bytes memory _message,
+        uint32 _gasLimit
+    )
+        internal
+    {   
+        iOVM_BaseCrossDomainMessenger(
+            bridge
+        ).sendMessage(
+            partner,
+            _message,
+            _gasLimit
+        );
+    }
+}

contracts/Layer2Bridged.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >0.6.0 <0.8.0;
+
+import { ERC20 } from "./ERC20.sol";
+import { Layer2Bridged } from "./Layer2Bridged.sol";
+
+contract Layer2ERC20 is ERC20, Layer2Bridged {
+
+    /**
+     * @param _initialSupply Initial maximum token supply.
+     * @param _name A name for our ERC20 (technically optional, but it's fun ok jeez).
+     */
+    constructor(
+        uint256 _initialSupply,
+        string memory _name
+    )
+        public
+        ERC20(_initialSupply, _name)
+    {}
+
+    function mint(
+        address _recipient,
+        uint256 _amount
+    )
+        public
+        onlyViaBridge
+    {
+        balances[_recipient] += _amount;
+        totalSupply += _amount;
+    }
+
+    function withdraw(
+        uint256 _amount
+    )
+        public
+    {
+        require(
+            balances[msg.sender] >= _amount,
+            "You don't have enough balance!"
+        );
+
+        balances[msg.sender] -= _amount;
+        totalSupply -= _amount;
+
+        bytes memory message = abi.encodeWithSignature(
+            "withdraw(address,uint256)",
+            msg.sender,
+            _amount
+        );
+
+        sendMessageViaBridge(
+            message,
+            8000000
+        );
+    }
+}

contracts/Layer2ERC20.sol

@@ -0,0 +1,13 @@
+import { HardhatUserConfig } from 'hardhat/types'
+
+import '@nomiclabs/hardhat-ethers'
+import '@nomiclabs/hardhat-waffle'
+
+import '@eth-optimism/plugins/hardhat/compiler'
+import '@eth-optimism/plugins/hardhat/ethers'
+
+const config: HardhatUserConfig = {
+  solidity: "0.7.3",
+};
+
+export default config