L2 Safe (#280)

Author: rmeissner

.github/workflows/ci.yml

@@ -20,6 +20,30 @@ jobs:
         uses: coverallsapp/github-action@master
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
+  tests-other:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        contract-name: ["GnosisSafeL2"]
+    env:
+      SAFE_CONTRACT_UNDER_TEST: ${{ matrix.contract-name }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 15
+      - uses: actions/cache@v2
+        with:
+          path: "**/node_modules"
+          key: ${{ runner.os }}-modules-${{ hashFiles('**/yarn.lock') }}
+      - run: yarn
+      - run: yarn build
+      - run: yarn coverage
+      - name: Coveralls
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
   benchmarks:
     runs-on: ubuntu-latest
     strategy:

benchmark/GnosisSafe.ERC1155.spec.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 import { waffle, ethers } from "hardhat";
 import "@nomiclabs/hardhat-ethers";
-import { buildSafeTransaction } from "../test/utils/execution";
+import { buildSafeTransaction } from "../src/utils/execution";
 import { BigNumber } from "ethers";
 import { benchmark, Contracts } from "./utils/setup"
 

benchmark/GnosisSafe.ERC20.spec.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 import { waffle, ethers } from "hardhat";
 import "@nomiclabs/hardhat-ethers";
-import { buildSafeTransaction } from "../test/utils/execution";
+import { buildSafeTransaction } from "../src/utils/execution";
 import { BigNumber } from "ethers";
 import { benchmark, Contracts } from "./utils/setup"
 

benchmark/GnosisSafe.Ether.spec.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 import { waffle, ethers } from "hardhat";
 import "@nomiclabs/hardhat-ethers";
-import { buildSafeTransaction } from "../test/utils/execution";
+import { buildSafeTransaction } from "../src/utils/execution";
 import { BigNumber } from "ethers";
 import { benchmark } from "./utils/setup"
 

benchmark/GnosisSafe.Proxy.spec.ts

@@ -1,8 +1,5 @@
-import { expect } from "chai";
-import { waffle, ethers } from "hardhat";
 import "@nomiclabs/hardhat-ethers";
-import { buildSafeTransaction } from "../test/utils/execution";
-import { BigNumber } from "ethers";
+import { buildSafeTransaction } from "../src/utils/execution";
 import { benchmark } from "./utils/setup"
 import { getFactory } from "../test/utils/setup";
 

benchmark/utils/setup.ts

@@ -2,7 +2,7 @@ import { expect } from "chai";
 import hre, { deployments, waffle } from "hardhat";
 import "@nomiclabs/hardhat-ethers";
 import { getDefaultCallbackHandler, getSafeWithOwners } from "../../test/utils/setup";
-import { logGas, executeTx, SafeTransaction, safeSignTypedData, SafeSignature, executeContractCallWithSigners } from "../../test/utils/execution";
+import { logGas, executeTx, SafeTransaction, safeSignTypedData, SafeSignature, executeContractCallWithSigners } from "../../src/utils/execution";
 import { Wallet, Contract } from "ethers";
 import { AddressZero } from "@ethersproject/constants";
 

contracts/GnosisSafe.sol

@@ -134,6 +134,7 @@ contract GnosisSafe
         bytes memory signatures
     )
         public
+        virtual
         payable
         returns (bool success)
     {
@@ -193,12 +194,11 @@ contract GnosisSafe
         private
         returns (uint256 payment)
     {
-        // solium-disable-next-line security/no-tx-origin
+        // solhint-disable-next-line avoid-tx-origin
         address payable receiver = refundReceiver == address(0) ? payable(tx.origin) : refundReceiver;
         if (gasToken == address(0)) {
             // For ETH we will only adjust the gas price to not be higher than the actual used gas price
             payment = gasUsed.add(baseGas).mul(gasPrice < tx.gasprice ? gasPrice : tx.gasprice);
-            // solium-disable-next-line security/no-send
             require(receiver.send(payment), "GS011");
         } else {
             payment = gasUsed.add(baseGas).mul(gasPrice);
@@ -213,8 +213,8 @@ contract GnosisSafe
     * @param signatures Signature data that should be verified. Can be ECDSA signature, contract signature (EIP-1271) or approved hash.
     */
     function checkSignatures(bytes32 dataHash, bytes memory data, bytes memory signatures)
-        view
         public
+        view
     {
         // Load threshold to avoid multiple storage loads
         uint256 _threshold = threshold;
@@ -246,15 +246,15 @@ contract GnosisSafe
 
                 // Check if the contract signature is in bounds: start of data is s + 32 and end is start + signature length
                 uint256 contractSignatureLen;
-                // solium-disable-next-line security/no-inline-assembly
+                // solhint-disable-next-line no-inline-assembly
                 assembly {
                     contractSignatureLen := mload(add(add(signatures, s), 0x20))
                 }
                 require(uint256(s).add(32).add(contractSignatureLen) <= signatures.length, "GS023");
 
                 // Check signature
                 bytes memory contractSignature;
-                // solium-disable-next-line security/no-inline-assembly
+                // solhint-disable-next-line no-inline-assembly
                 assembly {
                     // The signature data for contract signatures is appended to the concatenated signatures and the offset is stored in s
                     contractSignature := add(add(signatures, s), 0x20)
@@ -296,7 +296,6 @@ contract GnosisSafe
     {
         uint256 startGas = gasleft();
         // We don't provide an error message here, as we use it to return the estimate
-        // solium-disable-next-line error-reason
         require(execute(to, value, data, operation, gasleft()));
         uint256 requiredGas = startGas - gasleft();
         // Convert response to string and return via error message
@@ -332,7 +331,7 @@ contract GnosisSafe
     /// @dev Returns the chain id used by this contract.
     function getChainId() public view returns (uint256) {
         uint256 id;
-        // solium-disable-next-line security/no-inline-assembly
+        // solhint-disable-next-line no-inline-assembly
         assembly {
             id := chainid()
         }

contracts/GnosisSafeL2.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import "./GnosisSafe.sol";
+
+/// @title Gnosis Safe - A multisignature wallet with support for confirmations using signed messages based on ERC191.
+/// @author Stefan George - <stefan@gnosis.io>
+/// @author Richard Meissner - <richard@gnosis.io>
+contract GnosisSafeL2
+    is GnosisSafe {
+
+    event SafeMultiSigTransaction(
+        address to,
+        uint256 value,
+        bytes data,
+        Enum.Operation operation,
+        uint256 safeTxGas,
+        uint256 baseGas,
+        uint256 gasPrice,
+        address gasToken,
+        address payable refundReceiver,
+        bytes signatures,
+        // We combine nonce, sender and threshold into one to avoid stack too deep
+        // Dev note: additionalInfo should not contain `bytes`, as this complicates decoding
+        bytes additionalInfo
+    );
+
+    event SafeModuleTransaction(
+        address module,
+        address to,
+        uint256 value,
+        bytes data,
+        Enum.Operation operation
+    );
+
+    /// @dev Allows to execute a Safe transaction confirmed by required number of owners and then pays the account that submitted the transaction.
+    ///      Note: The fees are always transfered, even if the user transaction fails.
+    /// @param to Destination address of Safe transaction.
+    /// @param value Ether value of Safe transaction.
+    /// @param data Data payload of Safe transaction.
+    /// @param operation Operation type of Safe transaction.
+    /// @param safeTxGas Gas that should be used for the Safe transaction.
+    /// @param baseGas Gas costs that are independent of the transaction execution(e.g. base transaction fee, signature check, payment of the refund)
+    /// @param gasPrice Gas price that should be used for the payment calculation.
+    /// @param gasToken Token address (or 0 if ETH) that is used for the payment.
+    /// @param refundReceiver Address of receiver of gas payment (or 0 if tx.origin).
+    /// @param signatures Packed signature data ({bytes32 r}{bytes32 s}{uint8 v})
+    function execTransaction(
+        address to,
+        uint256 value,
+        bytes calldata data,
+        Enum.Operation operation,
+        uint256 safeTxGas,
+        uint256 baseGas,
+        uint256 gasPrice,
+        address gasToken,
+        address payable refundReceiver,
+        bytes memory signatures
+    )
+        public
+        override
+        payable
+        returns (bool)
+    {
+        bytes memory additionalInfo;
+        {
+            additionalInfo = abi.encode(nonce, msg.sender, threshold);
+        }
+        emit SafeMultiSigTransaction(
+            to,
+            value,
+            data,
+            operation,
+            safeTxGas,
+            baseGas,
+            gasPrice,
+            gasToken,
+            refundReceiver,
+            signatures,
+            additionalInfo
+        );
+        return super.execTransaction(
+            to,
+            value,
+            data,
+            operation,
+            safeTxGas,
+            baseGas,
+            gasPrice,
+            gasToken,
+            refundReceiver,
+            signatures
+        );
+    }
+
+    /// @dev Allows a Module to execute a Safe transaction without any further confirmations.
+    /// @param to Destination address of module transaction.
+    /// @param value Ether value of module transaction.
+    /// @param data Data payload of module transaction.
+    /// @param operation Operation type of module transaction.
+    function execTransactionFromModule(address to, uint256 value, bytes memory data, Enum.Operation operation)
+        public
+        override
+        returns (bool success)
+    {
+        emit SafeModuleTransaction(
+            msg.sender,
+            to,
+            value,
+            data,
+            operation
+        );
+        success = super.execTransactionFromModule(to, value, data, operation);
+    }
+}

contracts/accessors/SimulateTxAccessor.sol

@@ -8,7 +8,7 @@ import "../base/Executor.sol";
 contract SimulateTxAccessor is Executor {
 
     bytes32 constant private GUARD_VALUE = keccak256("simulate_tx_accessor.guard.bytes32");
-    bytes32 guard;
+    bytes32 private guard;
 
     constructor() {
         guard = GUARD_VALUE;
@@ -27,7 +27,7 @@ contract SimulateTxAccessor is Executor {
         uint256 startGas = gasleft();
         success = execute(to, value, data, operation, gasleft());
         estimate = startGas - gasleft();
-        // solium-disable-next-line security/no-inline-assembly
+        // solhint-disable-next-line no-inline-assembly
         assembly {
             // Load free memory location
             let ptr := mload(0x40)

contracts/base/Executor.sol

@@ -13,7 +13,7 @@ contract Executor {
         uint256 txGas
     ) internal returns (bool success) {
         if (operation == Enum.Operation.DelegateCall) {
-            // solium-disable-next-line security/no-inline-assembly
+            // solhint-disable-next-line no-inline-assembly
             assembly {
                 success := delegatecall(
                     txGas,
@@ -25,7 +25,7 @@ contract Executor {
                 )
             }
         } else {
-            // solium-disable-next-line security/no-inline-assembly
+            // solhint-disable-next-line no-inline-assembly
             assembly {
                 success := call(
                     txGas,