Gnosis Safe

1// SPDX-License-Identifier: LGPL-3.0-only
2pragma solidity >=0.7.0 <0.9.0;
3
4import "./GnosisSafeProxy.sol";
5import "./IProxyCreationCallback.sol";
6
7/// @title Proxy Factory - Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
8/// @author Stefan George - <stefan@gnosis.pm>
9contract GnosisSafeProxyFactory {
10    event ProxyCreation(GnosisSafeProxy proxy, address singleton);
11
12    /// @dev Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
13    /// @param singleton Address of singleton contract.
14    /// @param data Payload for message call sent to new proxy contract.
15    function createProxy(address singleton, bytes memory data) public returns (GnosisSafeProxy proxy) {
16        proxy = new GnosisSafeProxy(singleton);
17        if (data.length > 0)
18            // solhint-disable-next-line no-inline-assembly
19            assembly {
20                if eq(call(gas(), proxy, 0, add(data, 0x20), mload(data), 0, 0), 0) {
21                    revert(0, 0)
22                }
23            }
24        emit ProxyCreation(proxy, singleton);
25    }
26
27    /// @dev Allows to retrieve the runtime code of a deployed Proxy. This can be used to check that the expected Proxy was deployed.
28    function proxyRuntimeCode() public pure returns (bytes memory) {
29        return type(GnosisSafeProxy).runtimeCode;
30    }
31
32    /// @dev Allows to retrieve the creation code used for the Proxy deployment. With this it is easily possible to calculate predicted address.
33    function proxyCreationCode() public pure returns (bytes memory) {
34        return type(GnosisSafeProxy).creationCode;
35    }
36
37    /// @dev Allows to create new proxy contact using CREATE2 but it doesn't run the initializer.
38    ///      This method is only meant as an utility to be called from other methods
39    /// @param _singleton Address of singleton contract.
40    /// @param initializer Payload for message call sent to new proxy contract.
41    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
42    function deployProxyWithNonce(
43        address _singleton,
44        bytes memory initializer,
45        uint256 saltNonce
46    ) internal returns (GnosisSafeProxy proxy) {
47        // If the initializer changes the proxy address should change too. Hashing the initializer data is cheaper than just concatinating it
48        bytes32 salt = keccak256(abi.encodePacked(keccak256(initializer), saltNonce));
49        bytes memory deploymentData = abi.encodePacked(type(GnosisSafeProxy).creationCode, uint256(uint160(_singleton)));
50        // solhint-disable-next-line no-inline-assembly
51        assembly {
52            proxy := create2(0x0, add(0x20, deploymentData), mload(deploymentData), salt)
53        }
54        require(address(proxy) != address(0), "Create2 call failed");
55    }
56
57    /// @dev Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
58    /// @param _singleton Address of singleton contract.
59    /// @param initializer Payload for message call sent to new proxy contract.
60    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
61    function createProxyWithNonce(
62        address _singleton,
63        bytes memory initializer,
64        uint256 saltNonce
65    ) public returns (GnosisSafeProxy proxy) {
66        proxy = deployProxyWithNonce(_singleton, initializer, saltNonce);
67        if (initializer.length > 0)
68            // solhint-disable-next-line no-inline-assembly
69            assembly {
70                if eq(call(gas(), proxy, 0, add(initializer, 0x20), mload(initializer), 0, 0), 0) {
71                    revert(0, 0)
72                }
73            }
74        emit ProxyCreation(proxy, _singleton);
75    }
76
77    /// @dev Allows to create new proxy contact, execute a message call to the new proxy and call a specified callback within one transaction
78    /// @param _singleton Address of singleton contract.
79    /// @param initializer Payload for message call sent to new proxy contract.
80    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
81    /// @param callback Callback that will be invoced after the new proxy contract has been successfully deployed and initialized.
82    function createProxyWithCallback(
83        address _singleton,
84        bytes memory initializer,
85        uint256 saltNonce,
86        IProxyCreationCallback callback
87    ) public returns (GnosisSafeProxy proxy) {
88        uint256 saltNonceWithCallback = uint256(keccak256(abi.encodePacked(saltNonce, callback)));
89        proxy = createProxyWithNonce(_singleton, initializer, saltNonceWithCallback);
90        if (address(callback) != address(0)) callback.proxyCreated(proxy, _singleton, initializer, saltNonce);
91    }
92
93    /// @dev Allows to get the address for a new proxy contact created via `createProxyWithNonce`
94    ///      This method is only meant for address calculation purpose when you use an initializer that would revert,
95    ///      therefore the response is returned with a revert. When calling this method set `from` to the address of the proxy factory.
96    /// @param _singleton Address of singleton contract.
97    /// @param initializer Payload for message call sent to new proxy contract.
98    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
99    function calculateCreateProxyWithNonceAddress(
100        address _singleton,
101        bytes calldata initializer,
102        uint256 saltNonce
103    ) external returns (GnosisSafeProxy proxy) {
104        proxy = deployProxyWithNonce(_singleton, initializer, saltNonce);
105        revert(string(abi.encodePacked(proxy)));
106    }
107}