feat(execute): skip deterministic factory deploy when it can't be bootstrapped (#2944)

* feat(execute): skip the deterministic factory deploy (and dependent tests) when it can't be bootstrapped

The deterministic deployment proxy is bootstrapped in an autouse session
fixture via a keyless transaction with a fixed gas limit. On chains where the
contract-creation intrinsic gas exceeds that limit (so the keyless tx can never
be mined), the deploy aborted the entire execute session, blocking even tests
that never use the factory.

- Pre-flight the deploy with `eth_estimateGas`: if the network requires more
  gas for the creation than the keyless tx's fixed gas limit, raise instead of
  attempting it (no funding tx, no doomed send, no inclusion wait).
- Make the session fixture best-effort: warn instead of raising, so tests that
  don't need the factory still run.
- Skip a test that requests a deterministic deployment when the factory is
  unavailable.
- Add `EthRPC.estimate_gas` for the pre-flight.

* chore: update comment

---------

Co-authored-by: LouisTsai <q1030176@gmail.com>

Author: nerolation

packages/testing/src/execution_testing/cli/pytest_commands/plugins/execute/contracts.py

@@ -20,6 +20,13 @@
 logger = get_logger(__name__)
 
 
+class DeterministicFactoryNotDeployableError(Exception):
+    """
+    Raised when the deterministic proxy cannot deploy.
+    Example: fixed gas limit insufficient for network creation cost.
+    """
+
+
 def check_deterministic_factory_deployment(
     *,
     eth_rpc: EthRPC,
@@ -96,6 +103,28 @@ def deploy_deterministic_factory_contract(
     ).with_signature_and_sender()
     deploy_tx_sender = deploy_tx.sender
     assert deploy_tx_sender is not None
+
+    # Pre-flight: skip deploy if network gas > fixed limit.
+    # Gas limit is fixed as changing it alters sender/factory address.
+    # If network requires more gas, transaction can never be included.
+    try:
+        required_gas = eth_rpc.estimate_gas(
+            transaction={
+                "from": f"{deploy_tx_sender}",
+                "input": f"{deploy_tx.data}",
+            }
+        )
+    except Exception:
+        # If the estimate itself is unavailable, fall through and attempt the
+        # deploy as before (failures are still handled by the caller).
+        required_gas = None
+    if required_gas is not None and required_gas > deploy_tx_gas_limit:
+        raise DeterministicFactoryNotDeployableError(
+            f"network requires {required_gas} gas to create the deterministic "
+            f"deployment proxy, exceeding the keyless transaction's fixed gas "
+            f"limit of {deploy_tx_gas_limit}"
+        )
+
     required_deployer_balance = deploy_tx_gas_price * deploy_tx_gas_limit
     current_balance = eth_rpc.get_balance(deploy_tx_sender)
     if current_balance < required_deployer_balance:

packages/testing/src/execution_testing/cli/pytest_commands/plugins/execute/pre_alloc.py

@@ -152,6 +152,10 @@ def execute_required_contracts(
     Deploy required contracts for the execute command.
 
     - Deterministic deployment proxy
+
+    Proxy deploy failure doesn't abort the session.
+    Tests skip deterministic deploys on use.
+    Details check `(see Alloc._resolve_deterministic_deploys)`.
     """
     base_lock_file = session_temp_folder / "execute_required_contracts.lock"
     with FileLock(base_lock_file):
@@ -171,12 +175,13 @@ def execute_required_contracts(
                     gas_price=sender_funding_transactions_gas_price,
                 )
             except Exception as e:
-                raise RuntimeError(
-                    f"Error deploying deterministic deployment contract:\n{e}"
-                    "\nTry deploying the contract manually using a different "
-                    "RPC endpoint with the following command:\n"
-                    "uv run execute deploy-required-contracts"
-                ) from e
+                logger.warning(
+                    "Could not deploy the deterministic deployment proxy; "
+                    "tests that require it will be skipped. To deploy it "
+                    "manually against a different RPC endpoint run "
+                    "`uv run execute deploy-required-contracts`. "
+                    f"Reason: {e}"
+                )
 
 
 class PendingTransaction(Transaction):
@@ -794,12 +799,17 @@ def _resolve_deterministic_deploys(self) -> None:
                 )
             else:
                 if not factory_checked:
-                    assert (
+                    if (
                         check_deterministic_factory_deployment(
                             eth_rpc=self._eth_rpc, fork=fork
                         )
-                        is not None
-                    ), "Deployment contract code is not found"
+                        is None
+                    ):
+                        pytest.skip(
+                            "deterministic deployment proxy is not available "
+                            "on this network; skipping test that requires a "
+                            "deterministic contract deployment"
+                        )
                     factory_checked = True
 
                 logger.info(

packages/testing/src/execution_testing/rpc/rpc.py

@@ -634,6 +634,22 @@ def get_balances(
         responses = self.post_batch_request(calls=calls)
         return [int(r.result_or_raise(), 16) for r in responses]
 
+    def estimate_gas(
+        self,
+        transaction: Dict[str, Any],
+        block_number: BlockNumberType = "latest",
+    ) -> int:
+        """`eth_estimateGas`: Return the gas required to execute a tx."""
+        block = (
+            hex(block_number)
+            if isinstance(block_number, int)
+            else block_number
+        )
+        response = self.post_request(
+            request=RPCCall(method="estimateGas", params=[transaction, block])
+        ).result_or_raise()
+        return int(response, 16)
+
     def get_code(
         self, address: Address, block_number: BlockNumberType = "latest"
     ) -> Bytes: