ctb: Make implementations deployments deterministic and idempotent (#13717)

* ctb: Make implementations deployments deterministic and idempotent

* code review updates

* cr updates

* imports

* make superchain deployments deterministic

* forgot to add test

* code review updates

* broadcast in dpeloysuperchain

* add forgotten broadcast

Author: mslipper

op-chain-ops/interopgen/deploy.go

@@ -114,7 +114,7 @@ func CreateL1(logger log.Logger, fa *foundry.ArtifactsFS, srcFS *foundry.SourceM
 		PrevRandao:   cfg.L1GenesisBlockMixHash,
 		BlobHashes:   nil,
 	}
-	l1Host := script.NewHost(logger.New("role", "l1", "chain", cfg.ChainID), fa, srcFS, l1Context)
+	l1Host := script.NewHost(logger.New("role", "l1", "chain", cfg.ChainID), fa, srcFS, l1Context, script.WithCreate2Deployer())
 	return l1Host
 }
 

packages/contracts-bedrock/scripts/deploy/Deploy.s.sol

@@ -292,12 +292,8 @@ contract Deploy is Deployer {
         dii.set(dii.mipsVersion.selector, Config.useMultithreadedCannon() ? 2 : 1);
         string memory release = "dev";
         dii.set(dii.l1ContractsRelease.selector, release);
-        dii.set(
-            dii.standardVersionsToml.selector, string.concat(vm.projectRoot(), "/test/fixtures/standard-versions.toml")
-        );
         dii.set(dii.superchainConfigProxy.selector, artifacts.mustGetAddress("SuperchainConfigProxy"));
         dii.set(dii.protocolVersionsProxy.selector, artifacts.mustGetAddress("ProtocolVersionsProxy"));
-        dii.set(dii.salt.selector, _implSalt());
 
         if (_isInterop) {
             di = DeployImplementations(new DeployImplementationsInterop());

packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol

@@ -292,6 +292,8 @@ contract DeploySuperchainOutput is BaseDeployIO {
 // default sender would be the broadcaster during test, but the broadcaster needs to be the deployer
 // since they are set to the initial proxy admin owner.
 contract DeploySuperchain is Script {
+    bytes32 internal _salt = DeployUtils.DEFAULT_SALT;
+
     // -------- Core Deployment Methods --------
 
     function run(DeploySuperchainInput _dsi, DeploySuperchainOutput _dso) public {
@@ -342,15 +344,17 @@ contract DeploySuperchain is Script {
         // Deploy implementation contracts.
         vm.startBroadcast(msg.sender);
         ISuperchainConfig superchainConfigImpl = ISuperchainConfig(
-            DeployUtils.create1({
+            DeployUtils.createDeterministic({
                 _name: "SuperchainConfig",
-                _args: DeployUtils.encodeConstructor(abi.encodeCall(ISuperchainConfig.__constructor__, ()))
+                _args: DeployUtils.encodeConstructor(abi.encodeCall(ISuperchainConfig.__constructor__, ())),
+                _salt: _salt
             })
         );
         IProtocolVersions protocolVersionsImpl = IProtocolVersions(
-            DeployUtils.create1({
+            DeployUtils.createDeterministic({
                 _name: "ProtocolVersions",
-                _args: DeployUtils.encodeConstructor(abi.encodeCall(IProtocolVersions.__constructor__, ()))
+                _args: DeployUtils.encodeConstructor(abi.encodeCall(IProtocolVersions.__constructor__, ())),
+                _salt: _salt
             })
         );
         vm.stopBroadcast();

packages/contracts-bedrock/scripts/deploy/DeploySuperchain.s.sol

@@ -10,6 +10,7 @@ import { Artifacts } from "scripts/Artifacts.s.sol";
 import { LibString } from "@solady/utils/LibString.sol";
 import { Bytes } from "src/libraries/Bytes.sol";
 import { Constants } from "src/libraries/Constants.sol";
+import { Blueprint } from "src/libraries/Blueprint.sol";
 
 // Interfaces
 import { IProxy } from "interfaces/universal/IProxy.sol";
@@ -20,6 +21,8 @@ import { IResolvedDelegateProxy } from "interfaces/legacy/IResolvedDelegateProxy
 library DeployUtils {
     Vm internal constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
 
+    bytes32 internal constant DEFAULT_SALT = keccak256("op-stack-contract-impls-salt-v0");
+
     /// @notice Deploys a contract with the given name and arguments via CREATE.
     /// @param _name Name of the contract to deploy.
     /// @param _args ABI-encoded constructor arguments.
@@ -97,19 +100,11 @@ library DeployUtils {
     /// @param _args ABI-encoded constructor arguments.
     /// @param _salt Salt for the CREATE2 operation.
     /// @return addr_ Address of the deployed contract.
-    function create2(string memory _name, bytes memory _args, bytes32 _salt) internal returns (address payable addr_) {
+    function create2(string memory _name, bytes memory _args, bytes32 _salt) internal returns (address payable) {
         bytes memory initCode = abi.encodePacked(vm.getCode(_name), _args);
         address preComputedAddress = vm.computeCreate2Address(_salt, keccak256(initCode));
         require(preComputedAddress.code.length == 0, "DeployUtils: contract already deployed");
-        assembly {
-            addr_ := create2(0, add(initCode, 0x20), mload(initCode), _salt)
-            if iszero(addr_) {
-                let size := returndatasize()
-                returndatacopy(0, 0, size)
-                revert(0, size)
-            }
-        }
-        assertValidContractAddress(addr_);
+        return create2asm(initCode, _salt);
     }
 
     /// @notice Deploys a contract with the given name via CREATE2.
@@ -120,6 +115,18 @@ library DeployUtils {
         return create2(_name, hex"", _salt);
     }
 
+    function create2asm(bytes memory _initCode, bytes32 _salt) internal returns (address payable addr_) {
+        assembly {
+            addr_ := create2(0, add(_initCode, 0x20), mload(_initCode), _salt)
+            if iszero(addr_) {
+                let size := returndatasize()
+                returndatacopy(0, 0, size)
+                revert(0, size)
+            }
+        }
+        assertValidContractAddress(addr_);
+    }
+
     /// @notice Deploys a contract with the given name and arguments via CREATE2 and saves the result.
     /// @param _save Artifacts contract.
     /// @param _name Name of the contract to deploy.
@@ -195,6 +202,64 @@ library DeployUtils {
         return create2AndSave(_save, _name, _name, hex"", _salt);
     }
 
+    /// @notice Deploys a contract with the given name using CREATE2. If the contract is already deployed, this method
+    /// does nothing.
+    /// @param _name Name of the contract to deploy.
+    /// @param _args ABI-encoded constructor arguments.
+    function createDeterministic(
+        string memory _name,
+        bytes memory _args,
+        bytes32 _salt
+    )
+        internal
+        returns (address payable addr_)
+    {
+        bytes memory initCode = abi.encodePacked(vm.getCode(_name), _args);
+        address preComputedAddress = vm.computeCreate2Address(_salt, keccak256(initCode));
+        if (preComputedAddress.code.length > 0) {
+            addr_ = payable(preComputedAddress);
+        } else {
+            addr_ = DeployUtils.create2asm(initCode, _salt);
+        }
+    }
+
+    /// @notice Deploys a blueprint contract with the given name using CREATE2. If the contract is already deployed,
+    /// this method does nothing.
+    /// @param _rawBytecode Raw bytecode of the contract the blueprint will deploy.
+    function createDeterministicBlueprint(
+        bytes memory _rawBytecode,
+        bytes32 _salt
+    )
+        internal
+        returns (address newContract1_, address newContract2_)
+    {
+        uint32 maxSize = Blueprint.maxInitCodeSize();
+        if (_rawBytecode.length <= maxSize) {
+            bytes memory bpBytecode = Blueprint.blueprintDeployerBytecode(_rawBytecode);
+            newContract1_ = vm.computeCreate2Address(_salt, keccak256(bpBytecode));
+            if (newContract1_.code.length == 0) {
+                (address deployedContract) = Blueprint.deploySmallBytecode(bpBytecode, _salt);
+                require(deployedContract == newContract1_, "DeployUtils: unexpected blueprint address");
+            }
+            newContract2_ = address(0);
+        } else {
+            bytes memory part1Slice = Bytes.slice(_rawBytecode, 0, maxSize);
+            bytes memory part2Slice = Bytes.slice(_rawBytecode, maxSize, _rawBytecode.length - maxSize);
+            bytes memory bp1Bytecode = Blueprint.blueprintDeployerBytecode(part1Slice);
+            bytes memory bp2Bytecode = Blueprint.blueprintDeployerBytecode(part2Slice);
+            newContract1_ = vm.computeCreate2Address(_salt, keccak256(bp1Bytecode));
+            if (newContract1_.code.length == 0) {
+                address deployedContract = Blueprint.deploySmallBytecode(bp1Bytecode, _salt);
+                require(deployedContract == newContract1_, "DeployUtils: unexpected part 1 blueprint address");
+            }
+            newContract2_ = vm.computeCreate2Address(_salt, keccak256(bp2Bytecode));
+            if (newContract2_.code.length == 0) {
+                address deployedContract = Blueprint.deploySmallBytecode(bp2Bytecode, _salt);
+                require(deployedContract == newContract2_, "DeployUtils: unexpected part 2 blueprint address");
+            }
+        }
+    }
+
     /// @notice Takes a sender and an identifier and returns a deterministic address based on the
     ///         two. The result is used to etch the input and output contracts to a deterministic
     ///         address based on those two values, where the identifier represents the input or