@inco/lightning 0.6.8 → 0.7.0

package/src/pasted-dependencies/CreateX.sol

@@ -3,8 +3,8 @@ pragma solidity ^0.8;
 
 // inco note : pasted because importing createx using github forces a solc version we don't use
 
-address constant createXAddress = 0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed;
-address constant createXDeployer = 0xeD456e05CaAb11d66C4c797dD6c1D6f9A7F352b5;
+address constant CREATE_X_ADDRESS = 0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed;
+address constant CREATE_X_DEPLOYER = 0xeD456e05CaAb11d66C4c797dD6c1D6f9A7F352b5;
 
 /**
  * @title CreateX Factory Smart Contract
@@ -21,6 +21,7 @@ address constant createXDeployer = 0xeD456e05CaAb11d66C4c797dD6c1D6f9A7F352b5;
  * @custom:security-contact See https://web.archive.org/web/20230921105029/https://raw.githubusercontent.com/pcaversaccio/createx/main/SECURITY.md.
  */
 contract CreateX {
+
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                         IMMUTABLES                         */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
@@ -82,10 +83,7 @@ contract CreateX {
      * @param newContract The address of the new proxy contract.
      * @param salt The 32-byte random value used to create the proxy address.
      */
-    event Create3ProxyContractCreation(
-        address indexed newContract,
-        bytes32 indexed salt
-    );
+    event Create3ProxyContractCreation(address indexed newContract, bytes32 indexed salt);
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                        CUSTOM ERRORS                       */
@@ -135,15 +133,9 @@ contract CreateX {
      * @param initCode The creation bytecode.
      * @return newContract The 20-byte address where the contract was deployed.
      */
-    function deployCreate(
-        bytes memory initCode
-    ) public payable returns (address newContract) {
+    function deployCreate(bytes memory initCode) public payable returns (address newContract) {
         assembly ("memory-safe") {
-            newContract := create(
-                callvalue(),
-                add(initCode, 0x20),
-                mload(initCode)
-            )
+            newContract := create(callvalue(), add(initCode, 0x20), mload(initCode))
         }
         _requireSuccessfulContractCreation({newContract: newContract});
         emit ContractCreation({newContract: newContract});
@@ -164,43 +156,28 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreateAndInit(
-        bytes memory initCode,
-        bytes memory data,
-        Values memory values,
-        address refundAddress
-    ) public payable returns (address newContract) {
+    function deployCreateAndInit(bytes memory initCode, bytes memory data, Values memory values, address refundAddress)
+        public
+        payable
+        returns (address newContract)
+    {
         assembly ("memory-safe") {
-            newContract := create(
-                mload(values),
-                add(initCode, 0x20),
-                mload(initCode)
-            )
+            newContract := create(mload(values), add(initCode, 0x20), mload(initCode))
         }
         _requireSuccessfulContractCreation({newContract: newContract});
         emit ContractCreation({newContract: newContract});
 
-        (bool success, bytes memory returnData) = newContract.call{
-            value: values.initCallAmount
-        }(data);
+        (bool success, bytes memory returnData) = newContract.call{value: values.initCallAmount}(data);
         if (!success) {
-            revert FailedContractInitialisation({
-                emitter: _SELF,
-                revertData: returnData
-            });
+            revert FailedContractInitialisation({emitter: _SELF, revertData: returnData});
         }
 
         if (_SELF.balance != 0) {
             // Any wei amount previously forced into this contract (e.g. by using the `SELFDESTRUCT`
             // opcode) will be part of the refund transaction.
-            (success, returnData) = refundAddress.call{value: _SELF.balance}(
-                ""
-            );
+            (success, returnData) = refundAddress.call{value: _SELF.balance}("");
             if (!success) {
-                revert FailedEtherTransfer({
-                    emitter: _SELF,
-                    revertData: returnData
-                });
+                revert FailedEtherTransfer({emitter: _SELF, revertData: returnData});
             }
         }
     }
@@ -219,17 +196,12 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreateAndInit(
-        bytes memory initCode,
-        bytes memory data,
-        Values memory values
-    ) public payable returns (address newContract) {
-        newContract = deployCreateAndInit({
-            initCode: initCode,
-            data: data,
-            values: values,
-            refundAddress: msg.sender
-        });
+    function deployCreateAndInit(bytes memory initCode, bytes memory data, Values memory values)
+        public
+        payable
+        returns (address newContract)
+    {
+        newContract = deployCreateAndInit({initCode: initCode, data: data, values: values, refundAddress: msg.sender});
     }
 
     /**
@@ -244,22 +216,13 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreateClone(
-        address implementation,
-        bytes memory data
-    ) public payable returns (address proxy) {
+    function deployCreateClone(address implementation, bytes memory data) public payable returns (address proxy) {
         bytes20 implementationInBytes = bytes20(implementation);
         assembly ("memory-safe") {
             let clone := mload(0x40)
-            mstore(
-                clone,
-                hex"3d_60_2d_80_60_0a_3d_39_81_f3_36_3d_3d_37_3d_3d_3d_36_3d_73_00_00_00_00_00_00_00_00_00_00_00_00"
-            )
+            mstore(clone, hex"3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000")
             mstore(add(clone, 0x14), implementationInBytes)
-            mstore(
-                add(clone, 0x28),
-                hex"5a_f4_3d_82_80_3e_90_3d_91_60_2b_57_fd_5b_f3_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00"
-            )
+            mstore(add(clone, 0x28), hex"5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000")
             proxy := create(0, clone, 0x37)
         }
         if (proxy == address(0)) {
@@ -267,13 +230,9 @@ contract CreateX {
         }
         emit ContractCreation({newContract: proxy});
 
-        (bool success, bytes memory returnData) = proxy.call{value: msg.value}(
-            data
-        );
+        (bool success, bytes memory returnData) = proxy.call{value: msg.value}(data);
         _requireSuccessfulContractInitialisation({
-            success: success,
-            returnData: returnData,
-            implementation: implementation
+            success: success, returnData: returnData, implementation: implementation
         });
     }
 
@@ -291,10 +250,7 @@ contract CreateX {
      * @param nonce The next 32-byte nonce of the deployer address.
      * @return computedAddress The 20-byte address where a contract will be stored.
      */
-    function computeCreateAddress(
-        address deployer,
-        uint256 nonce
-    ) public view returns (address computedAddress) {
+    function computeCreateAddress(address deployer, uint256 nonce) public view returns (address computedAddress) {
         bytes memory data;
         bytes1 len = bytes1(0x94);
 
@@ -320,69 +276,21 @@ contract CreateX {
         // 0x94 = 0x80 + 0x14 (= the bytes length of an address, 20 bytes, in hex),
         // 0x84 = 0x80 + 0x04 (= the bytes length of the nonce, 4 bytes, in hex).
         else if (nonce <= type(uint8).max) {
-            data = abi.encodePacked(
-                bytes1(0xd7),
-                len,
-                deployer,
-                bytes1(0x81),
-                uint8(nonce)
-            );
+            data = abi.encodePacked(bytes1(0xd7), len, deployer, bytes1(0x81), uint8(nonce));
         } else if (nonce <= type(uint16).max) {
-            data = abi.encodePacked(
-                bytes1(0xd8),
-                len,
-                deployer,
-                bytes1(0x82),
-                uint16(nonce)
-            );
+            data = abi.encodePacked(bytes1(0xd8), len, deployer, bytes1(0x82), uint16(nonce));
         } else if (nonce <= type(uint24).max) {
-            data = abi.encodePacked(
-                bytes1(0xd9),
-                len,
-                deployer,
-                bytes1(0x83),
-                uint24(nonce)
-            );
+            data = abi.encodePacked(bytes1(0xd9), len, deployer, bytes1(0x83), uint24(nonce));
         } else if (nonce <= type(uint32).max) {
-            data = abi.encodePacked(
-                bytes1(0xda),
-                len,
-                deployer,
-                bytes1(0x84),
-                uint32(nonce)
-            );
+            data = abi.encodePacked(bytes1(0xda), len, deployer, bytes1(0x84), uint32(nonce));
         } else if (nonce <= type(uint40).max) {
-            data = abi.encodePacked(
-                bytes1(0xdb),
-                len,
-                deployer,
-                bytes1(0x85),
-                uint40(nonce)
-            );
+            data = abi.encodePacked(bytes1(0xdb), len, deployer, bytes1(0x85), uint40(nonce));
         } else if (nonce <= type(uint48).max) {
-            data = abi.encodePacked(
-                bytes1(0xdc),
-                len,
-                deployer,
-                bytes1(0x86),
-                uint48(nonce)
-            );
+            data = abi.encodePacked(bytes1(0xdc), len, deployer, bytes1(0x86), uint48(nonce));
         } else if (nonce <= type(uint56).max) {
-            data = abi.encodePacked(
-                bytes1(0xdd),
-                len,
-                deployer,
-                bytes1(0x87),
-                uint56(nonce)
-            );
+            data = abi.encodePacked(bytes1(0xdd), len, deployer, bytes1(0x87), uint56(nonce));
         } else {
-            data = abi.encodePacked(
-                bytes1(0xde),
-                len,
-                deployer,
-                bytes1(0x88),
-                uint64(nonce)
-            );
+            data = abi.encodePacked(bytes1(0xde), len, deployer, bytes1(0x88), uint64(nonce));
         }
 
         computedAddress = address(uint160(uint256(keccak256(data))));
@@ -401,9 +309,7 @@ contract CreateX {
      * @param nonce The next 32-byte nonce of this contract.
      * @return computedAddress The 20-byte address where a contract will be stored.
      */
-    function computeCreateAddress(
-        uint256 nonce
-    ) public view returns (address computedAddress) {
+    function computeCreateAddress(uint256 nonce) public view returns (address computedAddress) {
         computedAddress = computeCreateAddress({deployer: _SELF, nonce: nonce});
     }
 
@@ -420,18 +326,10 @@ contract CreateX {
      * @param initCode The creation bytecode.
      * @return newContract The 20-byte address where the contract was deployed.
      */
-    function deployCreate2(
-        bytes32 salt,
-        bytes memory initCode
-    ) public payable returns (address newContract) {
+    function deployCreate2(bytes32 salt, bytes memory initCode) public payable returns (address newContract) {
         bytes32 guardedSalt = _guard({salt: salt});
         assembly ("memory-safe") {
-            newContract := create2(
-                callvalue(),
-                add(initCode, 0x20),
-                mload(initCode),
-                guardedSalt
-            )
+            newContract := create2(callvalue(), add(initCode, 0x20), mload(initCode), guardedSalt)
         }
         _requireSuccessfulContractCreation({newContract: newContract});
         emit ContractCreation({newContract: newContract, salt: guardedSalt});
@@ -446,15 +344,10 @@ contract CreateX {
      * @param initCode The creation bytecode.
      * @return newContract The 20-byte address where the contract was deployed.
      */
-    function deployCreate2(
-        bytes memory initCode
-    ) public payable returns (address newContract) {
+    function deployCreate2(bytes memory initCode) public payable returns (address newContract) {
         // Note that the safeguarding function `_guard` is called as part of the overloaded function
         // `deployCreate2`.
-        newContract = deployCreate2({
-            salt: _generateSalt(),
-            initCode: initCode
-        });
+        newContract = deployCreate2({salt: _generateSalt(), initCode: initCode});
     }
 
     /**
@@ -482,37 +375,22 @@ contract CreateX {
     ) public payable returns (address newContract) {
         bytes32 guardedSalt = _guard({salt: salt});
         assembly ("memory-safe") {
-            newContract := create2(
-                mload(values),
-                add(initCode, 0x20),
-                mload(initCode),
-                guardedSalt
-            )
+            newContract := create2(mload(values), add(initCode, 0x20), mload(initCode), guardedSalt)
         }
         _requireSuccessfulContractCreation({newContract: newContract});
         emit ContractCreation({newContract: newContract, salt: guardedSalt});
 
-        (bool success, bytes memory returnData) = newContract.call{
-            value: values.initCallAmount
-        }(data);
+        (bool success, bytes memory returnData) = newContract.call{value: values.initCallAmount}(data);
         if (!success) {
-            revert FailedContractInitialisation({
-                emitter: _SELF,
-                revertData: returnData
-            });
+            revert FailedContractInitialisation({emitter: _SELF, revertData: returnData});
         }
 
         if (_SELF.balance != 0) {
             // Any wei amount previously forced into this contract (e.g. by using the `SELFDESTRUCT`
             // opcode) will be part of the refund transaction.
-            (success, returnData) = refundAddress.call{value: _SELF.balance}(
-                ""
-            );
+            (success, returnData) = refundAddress.call{value: _SELF.balance}("");
             if (!success) {
-                revert FailedEtherTransfer({
-                    emitter: _SELF,
-                    revertData: returnData
-                });
+                revert FailedEtherTransfer({emitter: _SELF, revertData: returnData});
             }
         }
     }
@@ -532,20 +410,15 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreate2AndInit(
-        bytes32 salt,
-        bytes memory initCode,
-        bytes memory data,
-        Values memory values
-    ) public payable returns (address newContract) {
+    function deployCreate2AndInit(bytes32 salt, bytes memory initCode, bytes memory data, Values memory values)
+        public
+        payable
+        returns (address newContract)
+    {
         // Note that the safeguarding function `_guard` is called as part of the overloaded function
         // `deployCreate2AndInit`.
         newContract = deployCreate2AndInit({
-            salt: salt,
-            initCode: initCode,
-            data: data,
-            values: values,
-            refundAddress: msg.sender
+            salt: salt, initCode: initCode, data: data, values: values, refundAddress: msg.sender
         });
     }
 
@@ -566,20 +439,15 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreate2AndInit(
-        bytes memory initCode,
-        bytes memory data,
-        Values memory values,
-        address refundAddress
-    ) public payable returns (address newContract) {
+    function deployCreate2AndInit(bytes memory initCode, bytes memory data, Values memory values, address refundAddress)
+        public
+        payable
+        returns (address newContract)
+    {
         // Note that the safeguarding function `_guard` is called as part of the overloaded function
         // `deployCreate2AndInit`.
         newContract = deployCreate2AndInit({
-            salt: _generateSalt(),
-            initCode: initCode,
-            data: data,
-            values: values,
-            refundAddress: refundAddress
+            salt: _generateSalt(), initCode: initCode, data: data, values: values, refundAddress: refundAddress
         });
     }
 
@@ -599,19 +467,15 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreate2AndInit(
-        bytes memory initCode,
-        bytes memory data,
-        Values memory values
-    ) public payable returns (address newContract) {
+    function deployCreate2AndInit(bytes memory initCode, bytes memory data, Values memory values)
+        public
+        payable
+        returns (address newContract)
+    {
         // Note that the safeguarding function `_guard` is called as part of the overloaded function
         // `deployCreate2AndInit`.
         newContract = deployCreate2AndInit({
-            salt: _generateSalt(),
-            initCode: initCode,
-            data: data,
-            values: values,
-            refundAddress: msg.sender
+            salt: _generateSalt(), initCode: initCode, data: data, values: values, refundAddress: msg.sender
         });
     }
 
@@ -628,24 +492,18 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreate2Clone(
-        bytes32 salt,
-        address implementation,
-        bytes memory data
-    ) public payable returns (address proxy) {
+    function deployCreate2Clone(bytes32 salt, address implementation, bytes memory data)
+        public
+        payable
+        returns (address proxy)
+    {
         bytes32 guardedSalt = _guard({salt: salt});
         bytes20 implementationInBytes = bytes20(implementation);
         assembly ("memory-safe") {
             let clone := mload(0x40)
-            mstore(
-                clone,
-                hex"3d_60_2d_80_60_0a_3d_39_81_f3_36_3d_3d_37_3d_3d_3d_36_3d_73_00_00_00_00_00_00_00_00_00_00_00_00"
-            )
+            mstore(clone, hex"3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000")
             mstore(add(clone, 0x14), implementationInBytes)
-            mstore(
-                add(clone, 0x28),
-                hex"5a_f4_3d_82_80_3e_90_3d_91_60_2b_57_fd_5b_f3_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00"
-            )
+            mstore(add(clone, 0x28), hex"5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000")
             proxy := create2(0, clone, 0x37, guardedSalt)
         }
         if (proxy == address(0)) {
@@ -653,13 +511,9 @@ contract CreateX {
         }
         emit ContractCreation({newContract: proxy, salt: guardedSalt});
 
-        (bool success, bytes memory returnData) = proxy.call{value: msg.value}(
-            data
-        );
+        (bool success, bytes memory returnData) = proxy.call{value: msg.value}(data);
         _requireSuccessfulContractInitialisation({
-            success: success,
-            returnData: returnData,
-            implementation: implementation
+            success: success, returnData: returnData, implementation: implementation
         });
     }
 
@@ -677,17 +531,10 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreate2Clone(
-        address implementation,
-        bytes memory data
-    ) public payable returns (address proxy) {
+    function deployCreate2Clone(address implementation, bytes memory data) public payable returns (address proxy) {
         // Note that the safeguarding function `_guard` is called as part of the overloaded function
         // `deployCreate2Clone`.
-        proxy = deployCreate2Clone({
-            salt: _generateSalt(),
-            implementation: implementation,
-            data: data
-        });
+        proxy = deployCreate2Clone({salt: _generateSalt(), implementation: implementation, data: data});
     }
 
     /**
@@ -700,11 +547,11 @@ contract CreateX {
      * @param deployer The 20-byte deployer address.
      * @return computedAddress The 20-byte address where a contract will be stored.
      */
-    function computeCreate2Address(
-        bytes32 salt,
-        bytes32 initCodeHash,
-        address deployer
-    ) public pure returns (address computedAddress) {
+    function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)
+        public
+        pure
+        returns (address computedAddress)
+    {
         assembly ("memory-safe") {
             // |                      | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
             // |----------------------|---------------------------------------------------------------------------|
@@ -733,15 +580,8 @@ contract CreateX {
      * @param initCodeHash The 32-byte bytecode digest of the contract creation bytecode.
      * @return computedAddress The 20-byte address where a contract will be stored.
      */
-    function computeCreate2Address(
-        bytes32 salt,
-        bytes32 initCodeHash
-    ) public view returns (address computedAddress) {
-        computedAddress = computeCreate2Address({
-            salt: salt,
-            initCodeHash: initCodeHash,
-            deployer: _SELF
-        });
+    function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) public view returns (address computedAddress) {
+        computedAddress = computeCreate2Address({salt: salt, initCodeHash: initCodeHash, deployer: _SELF});
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
@@ -762,36 +602,21 @@ contract CreateX {
      * the first 20 bytes equal to `msg.sender` in the `salt` to prevent maliciously intended frontrun
      * proxy deployments on other chains.
      */
-    function deployCreate3(
-        bytes32 salt,
-        bytes memory initCode
-    ) public payable returns (address newContract) {
+    function deployCreate3(bytes32 salt, bytes memory initCode) public payable returns (address newContract) {
         bytes32 guardedSalt = _guard({salt: salt});
-        bytes
-            memory proxyChildBytecode = hex"67_36_3d_3d_37_36_3d_34_f0_3d_52_60_08_60_18_f3";
+        bytes memory proxyChildBytecode = hex"67363d3d37363d34f03d5260086018f3";
         address proxy;
         assembly ("memory-safe") {
-            proxy := create2(
-                0,
-                add(proxyChildBytecode, 32),
-                mload(proxyChildBytecode),
-                guardedSalt
-            )
+            proxy := create2(0, add(proxyChildBytecode, 32), mload(proxyChildBytecode), guardedSalt)
         }
         if (proxy == address(0)) {
             revert FailedContractCreation({emitter: _SELF});
         }
-        emit Create3ProxyContractCreation({
-            newContract: proxy,
-            salt: guardedSalt
-        });
+        emit Create3ProxyContractCreation({newContract: proxy, salt: guardedSalt});
 
         newContract = computeCreate3Address({salt: guardedSalt});
-        (bool success, ) = proxy.call{value: msg.value}(initCode);
-        _requireSuccessfulContractCreation({
-            success: success,
-            newContract: newContract
-        });
+        (bool success,) = proxy.call{value: msg.value}(initCode);
+        _requireSuccessfulContractCreation({success: success, newContract: newContract});
         emit ContractCreation({newContract: newContract});
     }
 
@@ -806,15 +631,10 @@ contract CreateX {
      * @param initCode The creation bytecode.
      * @return newContract The 20-byte address where the contract was deployed.
      */
-    function deployCreate3(
-        bytes memory initCode
-    ) public payable returns (address newContract) {
+    function deployCreate3(bytes memory initCode) public payable returns (address newContract) {
         // Note that the safeguarding function `_guard` is called as part of the overloaded function
         // `deployCreate3`.
-        newContract = deployCreate3({
-            salt: _generateSalt(),
-            initCode: initCode
-        });
+        newContract = deployCreate3({salt: _generateSalt(), initCode: initCode});
     }
 
     /**
@@ -846,57 +666,33 @@ contract CreateX {
         address refundAddress
     ) public payable returns (address newContract) {
         bytes32 guardedSalt = _guard({salt: salt});
-        bytes
-            memory proxyChildBytecode = hex"67_36_3d_3d_37_36_3d_34_f0_3d_52_60_08_60_18_f3";
+        bytes memory proxyChildBytecode = hex"67363d3d37363d34f03d5260086018f3";
         address proxy;
         assembly ("memory-safe") {
-            proxy := create2(
-                0,
-                add(proxyChildBytecode, 32),
-                mload(proxyChildBytecode),
-                guardedSalt
-            )
+            proxy := create2(0, add(proxyChildBytecode, 32), mload(proxyChildBytecode), guardedSalt)
         }
         if (proxy == address(0)) {
             revert FailedContractCreation({emitter: _SELF});
         }
-        emit Create3ProxyContractCreation({
-            newContract: proxy,
-            salt: guardedSalt
-        });
+        emit Create3ProxyContractCreation({newContract: proxy, salt: guardedSalt});
 
         newContract = computeCreate3Address({salt: guardedSalt});
-        (bool success, ) = proxy.call{value: values.constructorAmount}(
-            initCode
-        );
-        _requireSuccessfulContractCreation({
-            success: success,
-            newContract: newContract
-        });
+        (bool success,) = proxy.call{value: values.constructorAmount}(initCode);
+        _requireSuccessfulContractCreation({success: success, newContract: newContract});
         emit ContractCreation({newContract: newContract});
 
         bytes memory returnData;
-        (success, returnData) = newContract.call{value: values.initCallAmount}(
-            data
-        );
+        (success, returnData) = newContract.call{value: values.initCallAmount}(data);
         if (!success) {
-            revert FailedContractInitialisation({
-                emitter: _SELF,
-                revertData: returnData
-            });
+            revert FailedContractInitialisation({emitter: _SELF, revertData: returnData});
         }
 
         if (_SELF.balance != 0) {
             // Any wei amount previously forced into this contract (e.g. by using the `SELFDESTRUCT`
             // opcode) will be part of the refund transaction.
-            (success, returnData) = refundAddress.call{value: _SELF.balance}(
-                ""
-            );
+            (success, returnData) = refundAddress.call{value: _SELF.balance}("");
             if (!success) {
-                revert FailedEtherTransfer({
-                    emitter: _SELF,
-                    revertData: returnData
-                });
+                revert FailedEtherTransfer({emitter: _SELF, revertData: returnData});
             }
         }
     }
@@ -921,20 +717,15 @@ contract CreateX {
      * the first 20 bytes equal to `msg.sender` in the `salt` to prevent maliciously intended frontrun
      * proxy deployments on other chains.
      */
-    function deployCreate3AndInit(
-        bytes32 salt,
-        bytes memory initCode,
-        bytes memory data,
-        Values memory values
-    ) public payable returns (address newContract) {
+    function deployCreate3AndInit(bytes32 salt, bytes memory initCode, bytes memory data, Values memory values)
+        public
+        payable
+        returns (address newContract)
+    {
         // Note that the safeguarding function `_guard` is called as part of the overloaded function
         // `deployCreate3AndInit`.
         newContract = deployCreate3AndInit({
-            salt: salt,
-            initCode: initCode,
-            data: data,
-            values: values,
-            refundAddress: msg.sender
+            salt: salt, initCode: initCode, data: data, values: values, refundAddress: msg.sender
         });
     }
 
@@ -956,20 +747,15 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreate3AndInit(
-        bytes memory initCode,
-        bytes memory data,
-        Values memory values,
-        address refundAddress
-    ) public payable returns (address newContract) {
+    function deployCreate3AndInit(bytes memory initCode, bytes memory data, Values memory values, address refundAddress)
+        public
+        payable
+        returns (address newContract)
+    {
         // Note that the safeguarding function `_guard` is called as part of the overloaded function
         // `deployCreate3AndInit`.
         newContract = deployCreate3AndInit({
-            salt: _generateSalt(),
-            initCode: initCode,
-            data: data,
-            values: values,
-            refundAddress: refundAddress
+            salt: _generateSalt(), initCode: initCode, data: data, values: values, refundAddress: refundAddress
         });
     }
 
@@ -990,19 +776,15 @@ contract CreateX {
      * a mutex lock to keep it as use-case agnostic as possible. Please ensure at the protocol
      * level that potentially malicious reentrant calls do not affect your smart contract system.
      */
-    function deployCreate3AndInit(
-        bytes memory initCode,
-        bytes memory data,
-        Values memory values
-    ) public payable returns (address newContract) {
+    function deployCreate3AndInit(bytes memory initCode, bytes memory data, Values memory values)
+        public
+        payable
+        returns (address newContract)
+    {
         // Note that the safeguarding function `_guard` is called as part of the overloaded function
         // `deployCreate3AndInit`.
         newContract = deployCreate3AndInit({
-            salt: _generateSalt(),
-            initCode: initCode,
-            data: data,
-            values: values,
-            refundAddress: msg.sender
+            salt: _generateSalt(), initCode: initCode, data: data, values: values, refundAddress: msg.sender
         });
     }
 
@@ -1015,19 +797,13 @@ contract CreateX {
      * @param deployer The 20-byte deployer address.
      * @return computedAddress The 20-byte address where a contract will be stored.
      */
-    function computeCreate3Address(
-        bytes32 salt,
-        address deployer
-    ) public pure returns (address computedAddress) {
+    function computeCreate3Address(bytes32 salt, address deployer) public pure returns (address computedAddress) {
         assembly ("memory-safe") {
             let ptr := mload(0x40)
             mstore(0x00, deployer)
             mstore8(0x0b, 0xff)
             mstore(0x20, salt)
-            mstore(
-                0x40,
-                hex"21_c3_5d_be_1b_34_4a_24_88_cf_33_21_d6_ce_54_2f_8e_9f_30_55_44_ff_09_e4_99_3a_62_31_9a_49_7c_1f"
-            )
+            mstore(0x40, hex"21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f")
             mstore(0x14, keccak256(0x0b, 0x55))
             mstore(0x40, ptr)
             mstore(0x00, 0xd694)
@@ -1044,9 +820,7 @@ contract CreateX {
      * @param salt The 32-byte random value used to create the proxy contract address.
      * @return computedAddress The 20-byte address where a contract will be stored.
      */
-    function computeCreate3Address(
-        bytes32 salt
-    ) public view returns (address computedAddress) {
+    function computeCreate3Address(bytes32 salt) public view returns (address computedAddress) {
         computedAddress = computeCreate3Address({salt: salt, deployer: _SELF});
     }
 
@@ -1068,50 +842,30 @@ contract CreateX {
      * @return guardedSalt The guarded 32-byte random value used to create the contract address.
      */
     function _guard(bytes32 salt) internal view returns (bytes32 guardedSalt) {
-        (
-            SenderBytes senderBytes,
-            RedeployProtectionFlag redeployProtectionFlag
-        ) = _parseSalt({salt: salt});
-
-        if (
-            senderBytes == SenderBytes.MsgSender &&
-            redeployProtectionFlag == RedeployProtectionFlag.True
-        ) {
+        (SenderBytes senderBytes, RedeployProtectionFlag redeployProtectionFlag) = _parseSalt({salt: salt});
+
+        if (senderBytes == SenderBytes.MsgSender && redeployProtectionFlag == RedeployProtectionFlag.True) {
             // Configures a permissioned deploy protection as well as a cross-chain redeploy protection.
-            guardedSalt = keccak256(
-                abi.encode(msg.sender, block.chainid, salt)
-            );
-        } else if (
-            senderBytes == SenderBytes.MsgSender &&
-            redeployProtectionFlag == RedeployProtectionFlag.False
-        ) {
+            guardedSalt = keccak256(abi.encode(msg.sender, block.chainid, salt));
+        } else if (senderBytes == SenderBytes.MsgSender && redeployProtectionFlag == RedeployProtectionFlag.False) {
             // Configures solely a permissioned deploy protection.
-            guardedSalt = _efficientHash({
-                a: bytes32(uint256(uint160(msg.sender))),
-                b: salt
-            });
+            guardedSalt = _efficientHash({a: bytes32(uint256(uint160(msg.sender))), b: salt});
         } else if (senderBytes == SenderBytes.MsgSender) {
             // Reverts if the 21st byte is greater than `0x01` in order to enforce developer explicitness.
             revert InvalidSalt({emitter: _SELF});
-        } else if (
-            senderBytes == SenderBytes.ZeroAddress &&
-            redeployProtectionFlag == RedeployProtectionFlag.True
-        ) {
+        } else if (senderBytes == SenderBytes.ZeroAddress && redeployProtectionFlag == RedeployProtectionFlag.True) {
             // Configures solely a cross-chain redeploy protection. In order to prevent a pseudo-randomly
             // generated cross-chain redeploy protection, we enforce the zero address check for the first 20 bytes.
             guardedSalt = _efficientHash({a: bytes32(block.chainid), b: salt});
         } else if (
-            senderBytes == SenderBytes.ZeroAddress &&
-            redeployProtectionFlag == RedeployProtectionFlag.Unspecified
+            senderBytes == SenderBytes.ZeroAddress && redeployProtectionFlag == RedeployProtectionFlag.Unspecified
         ) {
             // Reverts if the 21st byte is greater than `0x01` in order to enforce developer explicitness.
             revert InvalidSalt({emitter: _SELF});
         } else {
             // For the non-pseudo-random cases, the salt value `salt` is hashed to prevent the safeguard mechanisms
             // from being bypassed. Otherwise, the salt value `salt` is not modified.
-            guardedSalt = (salt != _generateSalt())
-                ? keccak256(abi.encode(salt))
-                : salt;
+            guardedSalt = (salt != _generateSalt()) ? keccak256(abi.encode(salt)) : salt;
         }
     }
 
@@ -1123,69 +877,29 @@ contract CreateX {
      * @return redeployProtectionFlag The 8-byte enum for the selection of a cross-chain redeploy
      * protection.
      */
-    function _parseSalt(
-        bytes32 salt
-    )
+    function _parseSalt(bytes32 salt)
         internal
         view
-        returns (
-            SenderBytes senderBytes,
-            RedeployProtectionFlag redeployProtectionFlag
-        )
+        returns (SenderBytes senderBytes, RedeployProtectionFlag redeployProtectionFlag)
     {
-        if (
-            address(bytes20(salt)) == msg.sender && bytes1(salt[20]) == hex"01"
-        ) {
-            (senderBytes, redeployProtectionFlag) = (
-                SenderBytes.MsgSender,
-                RedeployProtectionFlag.True
-            );
-        } else if (
-            address(bytes20(salt)) == msg.sender && bytes1(salt[20]) == hex"00"
-        ) {
-            (senderBytes, redeployProtectionFlag) = (
-                SenderBytes.MsgSender,
-                RedeployProtectionFlag.False
-            );
+        if (address(bytes20(salt)) == msg.sender && bytes1(salt[20]) == hex"01") {
+            (senderBytes, redeployProtectionFlag) = (SenderBytes.MsgSender, RedeployProtectionFlag.True);
+        } else if (address(bytes20(salt)) == msg.sender && bytes1(salt[20]) == hex"00") {
+            (senderBytes, redeployProtectionFlag) = (SenderBytes.MsgSender, RedeployProtectionFlag.False);
         } else if (address(bytes20(salt)) == msg.sender) {
-            (senderBytes, redeployProtectionFlag) = (
-                SenderBytes.MsgSender,
-                RedeployProtectionFlag.Unspecified
-            );
-        } else if (
-            address(bytes20(salt)) == address(0) && bytes1(salt[20]) == hex"01"
-        ) {
-            (senderBytes, redeployProtectionFlag) = (
-                SenderBytes.ZeroAddress,
-                RedeployProtectionFlag.True
-            );
-        } else if (
-            address(bytes20(salt)) == address(0) && bytes1(salt[20]) == hex"00"
-        ) {
-            (senderBytes, redeployProtectionFlag) = (
-                SenderBytes.ZeroAddress,
-                RedeployProtectionFlag.False
-            );
+            (senderBytes, redeployProtectionFlag) = (SenderBytes.MsgSender, RedeployProtectionFlag.Unspecified);
+        } else if (address(bytes20(salt)) == address(0) && bytes1(salt[20]) == hex"01") {
+            (senderBytes, redeployProtectionFlag) = (SenderBytes.ZeroAddress, RedeployProtectionFlag.True);
+        } else if (address(bytes20(salt)) == address(0) && bytes1(salt[20]) == hex"00") {
+            (senderBytes, redeployProtectionFlag) = (SenderBytes.ZeroAddress, RedeployProtectionFlag.False);
         } else if (address(bytes20(salt)) == address(0)) {
-            (senderBytes, redeployProtectionFlag) = (
-                SenderBytes.ZeroAddress,
-                RedeployProtectionFlag.Unspecified
-            );
+            (senderBytes, redeployProtectionFlag) = (SenderBytes.ZeroAddress, RedeployProtectionFlag.Unspecified);
         } else if (bytes1(salt[20]) == hex"01") {
-            (senderBytes, redeployProtectionFlag) = (
-                SenderBytes.Random,
-                RedeployProtectionFlag.True
-            );
+            (senderBytes, redeployProtectionFlag) = (SenderBytes.Random, RedeployProtectionFlag.True);
         } else if (bytes1(salt[20]) == hex"00") {
-            (senderBytes, redeployProtectionFlag) = (
-                SenderBytes.Random,
-                RedeployProtectionFlag.False
-            );
+            (senderBytes, redeployProtectionFlag) = (SenderBytes.Random, RedeployProtectionFlag.False);
         } else {
-            (senderBytes, redeployProtectionFlag) = (
-                SenderBytes.Random,
-                RedeployProtectionFlag.Unspecified
-            );
+            (senderBytes, redeployProtectionFlag) = (SenderBytes.Random, RedeployProtectionFlag.Unspecified);
         }
     }
 
@@ -1195,10 +909,7 @@ contract CreateX {
      * @param b The second 32-byte value to be concatenated and hashed.
      * @return hash The 32-byte `keccak256` hash of `a` and `b`.
      */
-    function _efficientHash(
-        bytes32 a,
-        bytes32 b
-    ) internal pure returns (bytes32 hash) {
+    function _efficientHash(bytes32 a, bytes32 b) internal pure returns (bytes32 hash) {
         assembly ("memory-safe") {
             mstore(0x00, a)
             mstore(0x20, b)
@@ -1241,21 +952,14 @@ contract CreateX {
      * @param success The Boolean success condition.
      * @param newContract The 20-byte address where the contract was deployed.
      */
-    function _requireSuccessfulContractCreation(
-        bool success,
-        address newContract
-    ) internal view {
+    function _requireSuccessfulContractCreation(bool success, address newContract) internal view {
         // Note that reverting if `newContract == address(0)` isn't strictly necessary here, as if
         // the deployment fails, `success == false` should already hold. However, since the `CreateX`
         // contract should be usable and safe on a wide range of chains, this check is cheap enough
         // that there is no harm in including it (security > gas optimisations). It can potentially
         // protect against unexpected chain behaviour or a hypothetical compiler bug that doesn't surface
         // the call success status properly.
-        if (
-            !success ||
-            newContract == address(0) ||
-            newContract.code.length == 0
-        ) {
+        if (!success || newContract == address(0) || newContract.code.length == 0) {
             revert FailedContractCreation({emitter: _SELF});
         }
     }
@@ -1264,9 +968,7 @@ contract CreateX {
      * @dev Ensures that `newContract` is a non-zero byte contract.
      * @param newContract The 20-byte address where the contract was deployed.
      */
-    function _requireSuccessfulContractCreation(
-        address newContract
-    ) internal view {
+    function _requireSuccessfulContractCreation(address newContract) internal view {
         if (newContract == address(0) || newContract.code.length == 0) {
             revert FailedContractCreation({emitter: _SELF});
         }
@@ -1278,16 +980,13 @@ contract CreateX {
      * @param returnData The return data from the contract initialisation call.
      * @param implementation The 20-byte address where the implementation was deployed.
      */
-    function _requireSuccessfulContractInitialisation(
-        bool success,
-        bytes memory returnData,
-        address implementation
-    ) internal view {
+    function _requireSuccessfulContractInitialisation(bool success, bytes memory returnData, address implementation)
+        internal
+        view
+    {
         if (!success || implementation.code.length == 0) {
-            revert FailedContractInitialisation({
-                emitter: _SELF,
-                revertData: returnData
-            });
+            revert FailedContractInitialisation({emitter: _SELF, revertData: returnData});
         }
     }
+
 }