Migrate contract deployer repo into contracts repo (#209)

Migrate contracts deployer repo into contracts repo
Pass msg.value when calling deploy to contract init code fragment for OwnableCreateDeploy
Resolve some solhint issues related to contract spacing / layout

Author: drinkcoffee

.gitmodules

@@ -22,3 +22,6 @@
 [submodule "lib/openzeppelin-contracts-5.0.2"]
 	path = lib/openzeppelin-contracts-5.0.2
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts
+[submodule "lib/axelar-gmp-sdk-solidity"]
+	path = lib/axelar-gmp-sdk-solidity
+	url = https://github.com/axelarnetwork/axelar-gmp-sdk-solidity

contracts/deployer/README.md

@@ -0,0 +1,90 @@
+# Contract Deployers
+
+At present, use of the Contract Deployers described below is limited to Immutable. 
+
+This directory provides two types of contract deployers: CREATE2 and CREATE3. Both deployer types facilitate contract deployment to predictable addresses, independent of the deployer account’s nonce. The deployers offer a more reliable alternative to using a Nonce Reserver Key (a key that is only used for deploying contracts, and has specific nonces reserved for deploying specific contracts), particularly across different chains. These factories can also be utilized for contracts that don't necessarily need predictable addresses. The advantage of this method, compared to using a deployer key in conjunction with a deployment factory contract, is that it can enable better standardisation and simplification of deployment processes and enables the rotation of the deployer key without impacting the consistency of the perceived deployer address for contracts.
+
+Deployments via these factories can only be performed by the owner of the factory. 
+
+**CAUTION**: When deploying a contract using one of these factories, it's crucial to note that `msg.sender` in the contract's constructor will refer to the contract factory's address and not to the deployer EOA. Therefore, any logic in a constructor that refers to `msg.sender` or assigns special privileges to this address would need to be changed.
+An example of this type of logic is the [`Ownable` contract in OpenZeppelin's v4.x](https://docs.openzeppelin.com/contracts/4.x/api/access#Ownable) library, which assigns default ownership of an inheriting contract to its deployer. When deploying a contract that inherits from `Ownable` using one of these factories, the contract's owner would thus be the factory. This would result in a loss of control over the contract. Hence, when deploying such a contract, it is necessary to ensure that a transfer of ownership from the factory to the desired owner is performed as part of the contract's construction. Specifically, a call to `transferOwnership(newOwner)` could be made to transfer ownership from the factory to the desired owner in the contract's constructor.
+
+
+# Status
+
+Contract audits and threat models:
+
+| Description               | Date             |Version Audited  | Link to Report |
+|---------------------------|------------------|-----------------|----------------|
+| Internal audit            | Work in Progress |                 |                |
+
+
+# Architecture
+
+## Create2 Deployer
+
+**Contract:** [`OwnableCreate2Deployer`](./create2/OwnableCreate2Deployer.sol)
+
+The [`OwnableCreate2Deployer`](./create2/OwnableCreate2Deployer.sol) uses the `CREATE2` opcode to deploy contracts to predictable addresses. The address of the deployed contract is determined by the following inputs:
+- **Contract Bytecode**: A contract's creation code. In Solidity this can be obtained using `type(contractName).creationCode`. For contracts with constructor arguments, the bytecode has to be encoded along with the relevant constructor arguments e.g. `abi.encodePacked(type(contractName).creationCode, abi.encode(args...))`.
+- **Salt**: The salt is a 32 byte value that is used to differentiate between different deployments.
+- **Deployer Address**: The address of the authorised deployer.
+- **Factory Address**: The address of the factory contract.
+
+The contract offers two functions for deployment:
+- `deploy(bytes memory bytecode, bytes32 salt)`: Deploys a contract to the address determined by the bytecode, salt and sender address. The bytecode should be encoded with the constructor arguments, if any.
+- `deployAndInit(bytes memory bytecode, bytes32 salt, bytes memory initCode)`: Deploys a contract to the address determined by the bytecode, salt and sender address, and executes the provided initialisation function after deployment. Contracts that are deployed on different chains, with the same salt and sender, will produce different addresses if the constructor parameters are different. `deployAndInit` offers one way to get around this issue, wherein contracts can define a separate `init` function that can be called after deployment, in place of having a constructor.
+
+The address that a contract will be deployed to, can be determined by calling the view function below:
+- `deployedAddress(bytes memory bytecode, bytes32 salt, address deployer)`: Returns the address that a contract will be deployed to, given the bytecode, salt and authorised deployer address.
+
+**Note:**  Alternatively, you can use the `CREATE3` deployer, described below.
+
+## Create3 Deployer
+**Contract:** [`OwnableCreate3Deployer`](./create3/OwnableCreate3Deployer.sol) 
+
+A limitation of the [`OwnableCreate2Deployer`](./create2/OwnableCreate2Deployer.sol) deployer is that the deployment addresses for contracts are influenced by specific constructor parameters used. This can pose a problem when identical contract addresses are needed across chains, but each chain requires different constructor arguments. The [`OwnableCreate3Deployer`](./create3/OwnableCreate3Deployer.sol) deployer addresses this issue by not requiring the contract bytecode as an input to determine the deployment address. The address of the deployed contract is determined solely by the following inputs:
+- **Salt**: A 32-byte value used to differentiate between various deployments.
+- **Deployer Address**: The address of the authorized deployer.
+- **Factory Address**: The address of the factory contract.
+
+Similar to the `OwnableCreate2Deployer`, the contract offers two functions for deployment:
+- `deploy(bytes memory bytecode, bytes32 salt)`: Deploys a contract to the address determined by the salt and sender address. The bytecode should be encoded with the constructor arguments, if any.
+- `deployAndInit(bytes memory bytecode, bytes32 salt, bytes memory initCode)`: Deploys a contract to the address determined by the salt and sender address, and executes the provided initialisation function after deployment.
+
+The address that a contract will be deployed to, can be determined by calling:
+- `deployedAddress(bytes memory, bytes32 salt, address deployer)`: Returns the address that a contract will be deployed to, given the salt and authorised deployer address. The first parameter is the bytecode of the contract, and can be left empty in the case of the `OwnableCreate3Deployer`, which is not influenced by the contract bytecode.
+
+
+
+# Deployed Addresses
+The addresses of the deployed factories are listed below. The addresses of the factories are the same on both the Ethereum and Immutable chain, for each environment.
+
+## Create2 Deployer
+There are two instances of the Create2 deployer deployed on Mainnet and Testnet. 
+While the contract behind both deployments are the same, their deployment configurations are different. The recommended deployer, as detailed below, ensures consistent addresses are generated for a given salt and bytecode across both chains (L1 and L2) and environments (Testnet and Mainnet). This means that a contract deployed with a given salt, will have the same address across L1 and L2 and across Testnet and Mainnet environments.
+The second Create2 deployer is now deprecated. While it ensures consistent addresses across chains (L1 and L2), it does not maintain this consistency across environments (Testnet vs Mainnet). Thus, a deployment with identical bytecode and salt will result in different addresses on Mainnet compared to Testnet.
+
+### Recommended
+
+|         | Testnet and Mainnet                          |
+|---------|----------------------------------------------|
+| Address | `0xeC3AAc81D3CE025E14620105d5e424c9a72B67B8` |
+| Owner   | `0xdDA0d9448Ebe3eA43aFecE5Fa6401F5795c19333` |
+
+
+### Deprecated
+
+|         | Testnet                                      | Mainnet                                      |
+|---------|----------------------------------------------|----------------------------------------------|
+| Address | `0xFd30E66f968F93F4c0C5AeA33601096A3fB2c48c` | `0x90DA206238384D33d7A35DCd7119c0CE76D37921` |
+| Owner   | `0xdDA0d9448Ebe3eA43aFecE5Fa6401F5795c19333` | `0xdDA0d9448Ebe3eA43aFecE5Fa6401F5795c19333` |
+
+## Create3 Deployer
+
+|         | Testnet and Mainnet                          |
+|---------|----------------------------------------------|
+| Address | `0x37a59A845Bb6eD2034098af8738fbFFB9D589610` |
+| Owner   | `0xdDA0d9448Ebe3eA43aFecE5Fa6401F5795c19333` |
+
+

contracts/deployer/create/OwnableCreateDeploy.sol

@@ -0,0 +1,32 @@
+// Copyright Immutable Pty Ltd 2018 - 2024
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.19;
+
+/**
+ * @title OwnableCreateDeploy Contract
+ * @notice This contract deploys new contracts using the `CREATE` opcode and is used as part of
+ * the `CREATE3` deployment method.
+ * @dev The contract can only be called by the owner of the contract, which is set to the deployer of the contract.
+ * @dev This is a copy of the `CreateDeploy` contract in Axelar's SDK, with a modification that adds basic access control to the deployment function.
+ *      see: https://github.com/axelarnetwork/axelar-gmp-sdk-solidity/blob/5f15a1036215f8b9c8eeb6438d352172b430dd38/contracts/deploy/CreateDeploy.sol
+ */
+contract OwnableCreateDeploy {
+    // Address that is authorised to call the deploy function.
+    address private immutable owner;
+
+    constructor() {
+        owner = msg.sender;
+    }
+    /**
+     * @dev Deploys a new contract with the specified bytecode using the `CREATE` opcode.
+     * @param bytecode The bytecode of the contract to be deployed
+     */
+    // slither-disable-next-line locked-ether
+    function deploy(bytes memory bytecode) external payable {
+        // solhint-disable-next-line custom-errors
+        require(msg.sender == owner, "CreateDeploy: caller is not the owner");
+        assembly {
+            if iszero(create(callvalue(), add(bytecode, 32), mload(bytecode))) { revert(0, 0) }
+        }
+    }
+}

contracts/deployer/create2/OwnableCreate2Deployer.sol

@@ -0,0 +1,49 @@
+// Copyright Immutable Pty Ltd 2018 - 2024
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity 0.8.19;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import {Deployer} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/deploy/Deployer.sol";
+import {Create2} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/deploy/Create2.sol";
+
+/**
+ * @title OwnableCreate2Deployer
+ * @notice Deploys and initializes contracts using the `CREATE2` opcode. The contract exposes two functions, {deploy} and {deployAndInit}.
+ *         {deploy} deploys a contract using the `CREATE2` opcode, and {deployAndInit} additionally initializes the contract using provided data.
+ *         The latter offers a way of ensuring that the constructor arguments do not affect the deployment address.
+ *
+ * @dev This contract extends the {Deployer} contract from the Axelar SDK, by adding basic access control to the deployment functions.
+ *      The contract has an owner, which is the only entity that can deploy new contracts.
+ *
+ * @dev The contract deploys a contract with the same bytecode, salt, and sender to the same address.
+ *      The address where the contract will be deployed can be found using {deployedAddress}.
+ */
+contract OwnableCreate2Deployer is Ownable, Create2, Deployer {
+    constructor(address owner) Ownable() {
+        transferOwnership(owner);
+    }
+
+    /**
+     * @dev Deploys a contract using the `CREATE2` opcode.
+     *      This function is called by {deploy} and {deployAndInit} external functions in the {Deployer} contract.
+     *      This function can only be called by the owner of this contract, hence the external {deploy} and {deployAndInit} functions can only be called by the owner.
+     *      The address where the contract will be deployed can be found using the {deployedAddress} function.
+     * @param bytecode The bytecode of the contract to be deployed
+     * @param deploySalt A salt which is a hash of the salt provided by the sender and the sender's address.
+     * @return The address of the deployed contract
+     */
+    function _deploy(bytes memory bytecode, bytes32 deploySalt) internal override onlyOwner returns (address) {
+        return _create2(bytecode, deploySalt);
+    }
+
+    /**
+     * @dev Returns the address where a contract will be stored if deployed via {deploy} or {deployAndInit}.
+     *      This function is called by the {deployedAddress} external functions in the {Deployer} contract.
+     * @param bytecode The bytecode of the contract to be deployed
+     * @param deploySalt A salt which is a hash of the sender's address and the `salt` provided by the sender, when calling the {deployedAddress} function.
+     * @return The predicted deployment address of the contract
+     */
+    function _deployedAddress(bytes memory bytecode, bytes32 deploySalt) internal view override returns (address) {
+        return _create2Address(bytecode, deploySalt);
+    }
+}

contracts/deployer/create3/OwnableCreate3.sol

@@ -0,0 +1,44 @@
+// Copyright Immutable Pty Ltd 2018 - 2024
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.19;
+
+import {IDeploy} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IDeploy.sol";
+import {ContractAddress} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/libs/ContractAddress.sol";
+
+import {OwnableCreate3Address} from "./OwnableCreate3Address.sol";
+import {OwnableCreateDeploy} from "../create/OwnableCreateDeploy.sol";
+
+/**
+ * @title OwnableCreate3 contract
+ * @notice This contract can be used to deploy a contract with a deterministic address that depends only on
+ *         the deployer address and deployment salt, not the contract bytecode and constructor parameters.
+ * @dev This contract is a copy of the `Create3` contract in Axelar's SDK, with a minor modification to use `OwnableCreateDeploy` instead of `CreateDeploy`.
+ *      See: https://github.com/axelarnetwork/axelar-gmp-sdk-solidity/blob/1d3dd9a42abd37a315c18ec51163ddc5e5a08c21/contracts/deploy/Create3.sol
+ */
+contract OwnableCreate3 is OwnableCreate3Address, IDeploy {
+    using ContractAddress for address;
+
+    /**
+     * @notice Deploys a new contract using the `CREATE3` method.
+     * @dev This function first deploys the CreateDeploy contract using
+     * the `CREATE2` opcode and then utilizes the CreateDeploy to deploy the
+     * new contract with the `CREATE` opcode.
+     * @param bytecode The bytecode of the contract to be deployed
+     * @param deploySalt A salt to influence the contract address
+     * @return deployed The address of the deployed contract
+     */
+    function _create3(bytes memory bytecode, bytes32 deploySalt) internal returns (address deployed) {
+        deployed = _create3Address(deploySalt);
+
+        if (bytecode.length == 0) revert EmptyBytecode();
+        if (deployed.isContract()) revert AlreadyDeployed();
+
+        // Deploy using create2
+        OwnableCreateDeploy create = new OwnableCreateDeploy{salt: deploySalt}();
+
+        if (address(create) == address(0)) revert DeployFailed();
+
+        // Deploy using create
+        create.deploy(bytecode);
+    }
+}

contracts/deployer/create3/OwnableCreate3Address.sol

@@ -0,0 +1,33 @@
+// Copyright Immutable Pty Ltd 2018 - 2024
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.19;
+
+import {OwnableCreateDeploy} from "../create/OwnableCreateDeploy.sol";
+
+/**
+ * @title OwnableCreate3Address contract
+ * @notice This contract can be used to predict the deterministic deployment address of a contract deployed with the `CREATE3` technique.
+ * @dev This contract is a copy of the `Create3Address` contract in Axelar's SDK, with a minor modification to use `OwnableCreateDeploy` instead of `CreateDeploy`.
+ *      See: https://github.com/axelarnetwork/axelar-gmp-sdk-solidity/blob/1d3dd9a42abd37a315c18ec51163ddc5e5a08c21/contracts/deploy/Create3Address.sol
+ */
+contract OwnableCreate3Address {
+    /// @dev bytecode hash of the CreateDeploy helper contract
+    bytes32 internal immutable createDeployBytecodeHash;
+
+    constructor() {
+        createDeployBytecodeHash = keccak256(type(OwnableCreateDeploy).creationCode);
+    }
+
+    /**
+     * @notice Compute the deployed address that will result from the `CREATE3` method.
+     * @param deploySalt A salt to influence the contract address
+     * @return deployed The deterministic contract address if it was deployed
+     */
+    function _create3Address(bytes32 deploySalt) internal view returns (address deployed) {
+        address deployer = address(
+            uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), deploySalt, createDeployBytecodeHash))))
+        );
+
+        deployed = address(uint160(uint256(keccak256(abi.encodePacked(hex"d694", deployer, hex"01")))));
+    }
+}

contracts/deployer/create3/OwnableCreate3Deployer.sol

@@ -0,0 +1,53 @@
+// Copyright Immutable Pty Ltd 2018 - 2023
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity 0.8.19;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import {Deployer} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/deploy/Deployer.sol";
+
+import {OwnableCreate3} from "./OwnableCreate3.sol";
+
+/**
+ * @title OwnableCreate3Deployer
+ * @notice The contract deploys contracts to deterministic addresses using the `CREATE3` method.
+ *         This address of deployed contracts depends only on the deployer address, and a provided salt.
+ *         Unlike the `CREATE2` deployment approach implemented in {OwnableCreate2Deployer}, the address of
+ *         contracts does not depend on the bytecode of the contract or constructor parameters.
+ *
+ * @dev This contract extends the {Deployer} contract from the Axelar SDK, by adding basic access control to the deployment functions.
+ *      The contract has an owner, which is the only entity that can deploy new contracts.
+ *
+ * @dev The contract deploys a contract with the same salt and sender to the same address.
+ *      The address where a contract will be deployed can be found using {deployedAddress}.
+ *
+ * @dev The contract deploys an single use intermediary contract using the `CREATE2` opcode, and then uses the intermediary contract to deploy the new contract using the `CREATE` opcode.
+ *      The intermediary contract is an instance of the {OwnableCreateDeploy} contract and can only be called by this contract.
+ */
+contract OwnableCreate3Deployer is Ownable, OwnableCreate3, Deployer {
+    constructor(address owner) Ownable() {
+        transferOwnership(owner);
+    }
+
+    /**
+     * @dev Deploys a contract using the `CREATE3` method.
+     *      This function is called by {deploy} and {deployAndInit} external functions in the {Deployer} contract.
+     *      This function can only be called by the owner of this contract, hence the external {deploy} and {deployAndInit} functions can only be called by the owner.
+     *      The address where the contract will be deployed can be found using the {deployedAddress} function.
+     * @param bytecode The bytecode of the contract to be deployed
+     * @param deploySalt A salt which is a hash of the salt provided by the sender and the sender's address.
+     * @return The address of the deployed contract
+     */
+    function _deploy(bytes memory bytecode, bytes32 deploySalt) internal override onlyOwner returns (address) {
+        return _create3(bytecode, deploySalt);
+    }
+
+    /**
+     * @dev Returns the address where a contract will be stored if deployed via {deploy} or {deployAndInit}.
+     *      This function is called by the {deployedAddress} external functions in the {Deployer} contract.
+     * @param deploySalt A salt which is a hash of the sender's address and the `salt` provided by the sender, when calling the {deployedAddress} function.
+     * @return The predicted deployment address of the contract
+     */
+    function _deployedAddress(bytes memory, bytes32 deploySalt) internal view override returns (address) {
+        return _create3Address(deploySalt);
+    }
+}