dequanto 0.0.1 → 0.1.3

package/test/fixtures/gnosis/interfaces/IERC165.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+/// @notice More details at https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol
+interface IERC165 {
+    /**
+     * @dev Returns true if this contract implements the interface defined by
+     * `interfaceId`. See the corresponding
+     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
+     * to learn more about how these ids are created.
+     *
+     * This function call must use less than 30 000 gas.
+     */
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}

package/test/fixtures/gnosis/interfaces/ISignatureValidator.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+contract ISignatureValidatorConstants {
+    // bytes4(keccak256("isValidSignature(bytes,bytes)")
+    bytes4 internal constant EIP1271_MAGIC_VALUE = 0x20c13b0b;
+}
+
+abstract contract ISignatureValidator is ISignatureValidatorConstants {
+    /**
+     * @dev Should return whether the signature provided is valid for the provided data
+     * @param _data Arbitrary length data signed on the behalf of address(this)
+     * @param _signature Signature byte array associated with _data
+     *
+     * MUST return the bytes4 magic value 0x20c13b0b when function passes.
+     * MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5)
+     * MUST allow external calls
+     */
+    function isValidSignature(bytes memory _data, bytes memory _signature) public view virtual returns (bytes4);
+}

package/test/fixtures/gnosis/interfaces/ViewStorageAccessible.sol

@@ -0,0 +1,11 @@
+pragma solidity >=0.5.0 <0.9.0;
+
+/// @title ViewStorageAccessible - Interface on top of StorageAccessible base class to allow simulations from view functions
+/// @notice Adjusted version of https://github.com/gnosis/util-contracts/blob/3db1e531cb243a48ea91c60a800d537c1000612a/contracts/StorageAccessible.sol
+interface ViewStorageAccessible {
+    /**
+     * @dev Same as `simulate` on StorageAccessible. Marked as view so that it can be called from external contracts
+     * that want to run simulations from within view functions. Will revert if the invoked simulation attempts to change state.
+     */
+    function simulate(address targetContract, bytes calldata calldataPayload) external view returns (bytes memory);
+}

package/test/fixtures/gnosis/libraries/CreateCall.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+/// @title Create Call - Allows to use the different create opcodes to deploy a contract
+/// @author Richard Meissner - <richard@gnosis.io>
+contract CreateCall {
+    event ContractCreation(address newContract);
+
+    function performCreate2(
+        uint256 value,
+        bytes memory deploymentData,
+        bytes32 salt
+    ) public returns (address newContract) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            newContract := create2(value, add(0x20, deploymentData), mload(deploymentData), salt)
+        }
+        require(newContract != address(0), "Could not deploy contract");
+        emit ContractCreation(newContract);
+    }
+
+    function performCreate(uint256 value, bytes memory deploymentData) public returns (address newContract) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            newContract := create(value, add(deploymentData, 0x20), mload(deploymentData))
+        }
+        require(newContract != address(0), "Could not deploy contract");
+        emit ContractCreation(newContract);
+    }
+}

package/test/fixtures/gnosis/libraries/GnosisSafeStorage.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+/// @title GnosisSafeStorage - Storage layout of the Safe contracts to be used in libraries
+/// @author Richard Meissner - <richard@gnosis.io>
+contract GnosisSafeStorage {
+    // From /common/Singleton.sol
+    address internal singleton;
+    // From /common/ModuleManager.sol
+    mapping(address => address) internal modules;
+    // From /common/OwnerManager.sol
+    mapping(address => address) internal owners;
+    uint256 internal ownerCount;
+    uint256 internal threshold;
+
+    // From /GnosisSafe.sol
+    uint256 internal nonce;
+    bytes32 internal _deprecatedDomainSeparator;
+    mapping(bytes32 => uint256) internal signedMessages;
+    mapping(address => mapping(bytes32 => uint256)) internal approvedHashes;
+}

package/test/fixtures/gnosis/libraries/MultiSend.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+/// @title Multi Send - Allows to batch multiple transactions into one.
+/// @author Nick Dodson - <nick.dodson@consensys.net>
+/// @author Gonçalo Sá - <goncalo.sa@consensys.net>
+/// @author Stefan George - <stefan@gnosis.io>
+/// @author Richard Meissner - <richard@gnosis.io>
+contract MultiSend {
+    address private immutable multisendSingleton;
+
+    constructor() {
+        multisendSingleton = address(this);
+    }
+
+    /// @dev Sends multiple transactions and reverts all if one fails.
+    /// @param transactions Encoded transactions. Each transaction is encoded as a packed bytes of
+    ///                     operation as a uint8 with 0 for a call or 1 for a delegatecall (=> 1 byte),
+    ///                     to as a address (=> 20 bytes),
+    ///                     value as a uint256 (=> 32 bytes),
+    ///                     data length as a uint256 (=> 32 bytes),
+    ///                     data as bytes.
+    ///                     see abi.encodePacked for more information on packed encoding
+    /// @notice This method is payable as delegatecalls keep the msg.value from the previous call
+    ///         If the calling method (e.g. execTransaction) received ETH this would revert otherwise
+    function multiSend(bytes memory transactions) public payable {
+        require(address(this) != multisendSingleton, "MultiSend should only be called via delegatecall");
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            let length := mload(transactions)
+            let i := 0x20
+            for {
+                // Pre block is not used in "while mode"
+            } lt(i, length) {
+                // Post block is not used in "while mode"
+            } {
+                // First byte of the data is the operation.
+                // We shift by 248 bits (256 - 8 [operation byte]) it right since mload will always load 32 bytes (a word).
+                // This will also zero out unused data.
+                let operation := shr(0xf8, mload(add(transactions, i)))
+                // We offset the load address by 1 byte (operation byte)
+                // We shift it right by 96 bits (256 - 160 [20 address bytes]) to right-align the data and zero out unused data.
+                let to := shr(0x60, mload(add(transactions, add(i, 0x01))))
+                // We offset the load address by 21 byte (operation byte + 20 address bytes)
+                let value := mload(add(transactions, add(i, 0x15)))
+                // We offset the load address by 53 byte (operation byte + 20 address bytes + 32 value bytes)
+                let dataLength := mload(add(transactions, add(i, 0x35)))
+                // We offset the load address by 85 byte (operation byte + 20 address bytes + 32 value bytes + 32 data length bytes)
+                let data := add(transactions, add(i, 0x55))
+                let success := 0
+                switch operation
+                    case 0 {
+                        success := call(gas(), to, value, data, dataLength, 0, 0)
+                    }
+                    case 1 {
+                        success := delegatecall(gas(), to, data, dataLength, 0, 0)
+                    }
+                if eq(success, 0) {
+                    revert(0, 0)
+                }
+                // Next entry starts at 85 byte + data length
+                i := add(i, add(0x55, dataLength))
+            }
+        }
+    }
+}

package/test/fixtures/gnosis/libraries/MultiSendCallOnly.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+/// @title Multi Send Call Only - Allows to batch multiple transactions into one, but only calls
+/// @author Stefan George - <stefan@gnosis.io>
+/// @author Richard Meissner - <richard@gnosis.io>
+/// @notice The guard logic is not required here as this contract doesn't support nested delegate calls
+contract MultiSendCallOnly {
+    /// @dev Sends multiple transactions and reverts all if one fails.
+    /// @param transactions Encoded transactions. Each transaction is encoded as a packed bytes of
+    ///                     operation has to be uint8(0) in this version (=> 1 byte),
+    ///                     to as a address (=> 20 bytes),
+    ///                     value as a uint256 (=> 32 bytes),
+    ///                     data length as a uint256 (=> 32 bytes),
+    ///                     data as bytes.
+    ///                     see abi.encodePacked for more information on packed encoding
+    /// @notice The code is for most part the same as the normal MultiSend (to keep compatibility),
+    ///         but reverts if a transaction tries to use a delegatecall.
+    /// @notice This method is payable as delegatecalls keep the msg.value from the previous call
+    ///         If the calling method (e.g. execTransaction) received ETH this would revert otherwise
+    function multiSend(bytes memory transactions) public payable {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            let length := mload(transactions)
+            let i := 0x20
+            for {
+                // Pre block is not used in "while mode"
+            } lt(i, length) {
+                // Post block is not used in "while mode"
+            } {
+                // First byte of the data is the operation.
+                // We shift by 248 bits (256 - 8 [operation byte]) it right since mload will always load 32 bytes (a word).
+                // This will also zero out unused data.
+                let operation := shr(0xf8, mload(add(transactions, i)))
+                // We offset the load address by 1 byte (operation byte)
+                // We shift it right by 96 bits (256 - 160 [20 address bytes]) to right-align the data and zero out unused data.
+                let to := shr(0x60, mload(add(transactions, add(i, 0x01))))
+                // We offset the load address by 21 byte (operation byte + 20 address bytes)
+                let value := mload(add(transactions, add(i, 0x15)))
+                // We offset the load address by 53 byte (operation byte + 20 address bytes + 32 value bytes)
+                let dataLength := mload(add(transactions, add(i, 0x35)))
+                // We offset the load address by 85 byte (operation byte + 20 address bytes + 32 value bytes + 32 data length bytes)
+                let data := add(transactions, add(i, 0x55))
+                let success := 0
+                switch operation
+                    case 0 {
+                        success := call(gas(), to, value, data, dataLength, 0, 0)
+                    }
+                    // This version does not allow delegatecalls
+                    case 1 {
+                        revert(0, 0)
+                    }
+                if eq(success, 0) {
+                    revert(0, 0)
+                }
+                // Next entry starts at 85 byte + data length
+                i := add(i, add(0x55, dataLength))
+            }
+        }
+    }
+}

package/test/fixtures/gnosis/libraries/SignMessageLib.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import "./GnosisSafeStorage.sol";
+import "../GnosisSafe.sol";
+
+/// @title SignMessageLib - Allows to set an entry in the signedMessages
+/// @author Richard Meissner - <richard@gnosis.io>
+contract SignMessageLib is GnosisSafeStorage {
+    //keccak256(
+    //    "SafeMessage(bytes message)"
+    //);
+    bytes32 private constant SAFE_MSG_TYPEHASH = 0x60b3cbf8b4a223d68d641b3b6ddf9a298e7f33710cf3d3a9d1146b5a6150fbca;
+
+    event SignMsg(bytes32 indexed msgHash);
+
+    /// @dev Marks a message as signed, so that it can be used with EIP-1271
+    /// @notice Marks a message (`_data`) as signed.
+    /// @param _data Arbitrary length data that should be marked as signed on the behalf of address(this)
+    function signMessage(bytes calldata _data) external {
+        bytes32 msgHash = getMessageHash(_data);
+        signedMessages[msgHash] = 1;
+        emit SignMsg(msgHash);
+    }
+
+    /// @dev Returns hash of a message that can be signed by owners.
+    /// @param message Message that should be hashed
+    /// @return Message hash.
+    function getMessageHash(bytes memory message) public view returns (bytes32) {
+        bytes32 safeMessageHash = keccak256(abi.encode(SAFE_MSG_TYPEHASH, keccak256(message)));
+        return
+            keccak256(abi.encodePacked(bytes1(0x19), bytes1(0x01), GnosisSafe(payable(address(this))).domainSeparator(), safeMessageHash));
+    }
+}

package/test/fixtures/gnosis/proxies/GnosisSafeProxy.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+/// @title IProxy - Helper interface to access masterCopy of the Proxy on-chain
+/// @author Richard Meissner - <richard@gnosis.io>
+interface IProxy {
+    function masterCopy() external view returns (address);
+}
+
+/// @title GnosisSafeProxy - Generic proxy contract allows to execute all transactions applying the code of a master contract.
+/// @author Stefan George - <stefan@gnosis.io>
+/// @author Richard Meissner - <richard@gnosis.io>
+contract GnosisSafeProxy {
+    // singleton always needs to be first declared variable, to ensure that it is at the same location in the contracts to which calls are delegated.
+    // To reduce deployment costs this variable is internal and needs to be retrieved via `getStorageAt`
+    address internal singleton;
+
+    /// @dev Constructor function sets address of singleton contract.
+    /// @param _singleton Singleton address.
+    constructor(address _singleton) {
+        require(_singleton != address(0), "Invalid singleton address provided");
+        singleton = _singleton;
+    }
+
+    /// @dev Fallback function forwards all transactions and returns all received return data.
+    fallback() external payable {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            let _singleton := and(sload(0), 0xffffffffffffffffffffffffffffffffffffffff)
+            // 0xa619486e == keccak("masterCopy()"). The value is right padded to 32-bytes with 0s
+            if eq(calldataload(0), 0xa619486e00000000000000000000000000000000000000000000000000000000) {
+                mstore(0, _singleton)
+                return(0, 0x20)
+            }
+            calldatacopy(0, 0, calldatasize())
+            let success := delegatecall(gas(), _singleton, 0, calldatasize(), 0, 0)
+            returndatacopy(0, 0, returndatasize())
+            if eq(success, 0) {
+                revert(0, returndatasize())
+            }
+            return(0, returndatasize())
+        }
+    }
+}

package/test/fixtures/gnosis/proxies/GnosisSafeProxyFactory.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+
+import "./GnosisSafeProxy.sol";
+import "./IProxyCreationCallback.sol";
+
+/// @title Proxy Factory - Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
+/// @author Stefan George - <stefan@gnosis.pm>
+contract GnosisSafeProxyFactory {
+    event ProxyCreation(GnosisSafeProxy proxy, address singleton);
+
+    /// @dev Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
+    /// @param singleton Address of singleton contract.
+    /// @param data Payload for message call sent to new proxy contract.
+    function createProxy(address singleton, bytes memory data) public returns (GnosisSafeProxy proxy) {
+        proxy = new GnosisSafeProxy(singleton);
+        if (data.length > 0)
+            // solhint-disable-next-line no-inline-assembly
+            assembly {
+                if eq(call(gas(), proxy, 0, add(data, 0x20), mload(data), 0, 0), 0) {
+                    revert(0, 0)
+                }
+            }
+        emit ProxyCreation(proxy, singleton);
+    }
+
+    /// @dev Allows to retrieve the runtime code of a deployed Proxy. This can be used to check that the expected Proxy was deployed.
+    function proxyRuntimeCode() public pure returns (bytes memory) {
+        return type(GnosisSafeProxy).runtimeCode;
+    }
+
+    /// @dev Allows to retrieve the creation code used for the Proxy deployment. With this it is easily possible to calculate predicted address.
+    function proxyCreationCode() public pure returns (bytes memory) {
+        return type(GnosisSafeProxy).creationCode;
+    }
+
+    /// @dev Allows to create new proxy contact using CREATE2 but it doesn't run the initializer.
+    ///      This method is only meant as an utility to be called from other methods
+    /// @param _singleton Address of singleton contract.
+    /// @param initializer Payload for message call sent to new proxy contract.
+    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
+    function deployProxyWithNonce(
+        address _singleton,
+        bytes memory initializer,
+        uint256 saltNonce
+    ) internal returns (GnosisSafeProxy proxy) {
+        // If the initializer changes the proxy address should change too. Hashing the initializer data is cheaper than just concatinating it
+        bytes32 salt = keccak256(abi.encodePacked(keccak256(initializer), saltNonce));
+        bytes memory deploymentData = abi.encodePacked(type(GnosisSafeProxy).creationCode, uint256(uint160(_singleton)));
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            proxy := create2(0x0, add(0x20, deploymentData), mload(deploymentData), salt)
+        }
+        require(address(proxy) != address(0), "Create2 call failed");
+    }
+
+    /// @dev Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
+    /// @param _singleton Address of singleton contract.
+    /// @param initializer Payload for message call sent to new proxy contract.
+    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
+    function createProxyWithNonce(
+        address _singleton,
+        bytes memory initializer,
+        uint256 saltNonce
+    ) public returns (GnosisSafeProxy proxy) {
+        proxy = deployProxyWithNonce(_singleton, initializer, saltNonce);
+        if (initializer.length > 0)
+            // solhint-disable-next-line no-inline-assembly
+            assembly {
+                if eq(call(gas(), proxy, 0, add(initializer, 0x20), mload(initializer), 0, 0), 0) {
+                    revert(0, 0)
+                }
+            }
+        emit ProxyCreation(proxy, _singleton);
+    }
+
+    /// @dev Allows to create new proxy contact, execute a message call to the new proxy and call a specified callback within one transaction
+    /// @param _singleton Address of singleton contract.
+    /// @param initializer Payload for message call sent to new proxy contract.
+    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
+    /// @param callback Callback that will be invoked after the new proxy contract has been successfully deployed and initialized.
+    function createProxyWithCallback(
+        address _singleton,
+        bytes memory initializer,
+        uint256 saltNonce,
+        IProxyCreationCallback callback
+    ) public returns (GnosisSafeProxy proxy) {
+        uint256 saltNonceWithCallback = uint256(keccak256(abi.encodePacked(saltNonce, callback)));
+        proxy = createProxyWithNonce(_singleton, initializer, saltNonceWithCallback);
+        if (address(callback) != address(0)) callback.proxyCreated(proxy, _singleton, initializer, saltNonce);
+    }
+
+    /// @dev Allows to get the address for a new proxy contact created via `createProxyWithNonce`
+    ///      This method is only meant for address calculation purpose when you use an initializer that would revert,
+    ///      therefore the response is returned with a revert. When calling this method set `from` to the address of the proxy factory.
+    /// @param _singleton Address of singleton contract.
+    /// @param initializer Payload for message call sent to new proxy contract.
+    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
+    function calculateCreateProxyWithNonceAddress(
+        address _singleton,
+        bytes calldata initializer,
+        uint256 saltNonce
+    ) external returns (GnosisSafeProxy proxy) {
+        proxy = deployProxyWithNonce(_singleton, initializer, saltNonce);
+        revert(string(abi.encodePacked(proxy)));
+    }
+}

package/test/fixtures/gnosis/proxies/IProxyCreationCallback.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.7.0 <0.9.0;
+import "./GnosisSafeProxy.sol";
+
+interface IProxyCreationCallback {
+    function proxyCreated(
+        GnosisSafeProxy proxy,
+        address _singleton,
+        bytes calldata initializer,
+        uint256 saltNonce
+    ) external;
+}