prepare anvil before deploy

src/SafeSingletonDeployer.sol

@@ -1,14 +1,20 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import {VmSafe} from "forge-std/Vm.sol";
+import {VmSafe, Vm} from "forge-std/Vm.sol";
 
 /// @notice Library for deploying contracts using Safe's Singleton Factory
 ///         https://github.com/safe-global/safe-singleton-factory
 library SafeSingletonDeployer {
+    error MissingSafeSingletonFactory();
     error DeployFailed();
 
     address constant SAFE_SINGLETON_FACTORY = 0x914d7Fec6aaC8cd542e72Bca78B30650d45643d7;
+
+    // cast code 0x914d7Fec6aaC8cd542e72Bca78B30650d45643d7 --rpc-url https://mainnet.base.org
+    bytes constant factoryCode =
+        hex"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3";
+
     VmSafe private constant VM = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
 
     function computeAddress(bytes memory creationCode, bytes32 salt) public pure returns (address) {
@@ -73,6 +79,13 @@ library SafeSingletonDeployer {
     }
 
     function _deploy(bytes memory creationCode, bytes memory args, bytes32 salt) private returns (address) {
+        // ensure Safe Singleton Factory exists if we're deploying to anvil
+        prepareAnvil();
+
+        if (SAFE_SINGLETON_FACTORY.code.length == 0) {
+            revert MissingSafeSingletonFactory();
+        }
+
         bytes memory callData = abi.encodePacked(salt, creationCode, args);
 
         (bool success, bytes memory result) = SAFE_SINGLETON_FACTORY.call(callData);
@@ -89,4 +102,10 @@ library SafeSingletonDeployer {
     function _hashInitCode(bytes memory creationCode, bytes memory args) private pure returns (bytes32) {
         return keccak256(abi.encodePacked(creationCode, args));
     }
+
+    function prepareAnvil() public {
+        if (block.chainid == 31337) {
+            Vm(address(VM)).etch(SafeSingletonDeployer.SAFE_SINGLETON_FACTORY, factoryCode);
+        }
+    }
 }

test/SafeSingletonDeployer.t.sol

@@ -9,14 +9,6 @@ import {Mock} from "./Mock.sol";
 import {MockReverting} from "./MockReverting.sol";
 
 contract SafeSingletonDeployerTest is Test {
-    // cast code 0x914d7Fec6aaC8cd542e72Bca78B30650d45643d7 --rpc-url https://mainnet.base.org
-    bytes factoryCode =
-        hex"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3";
-
-    function setUp() public {
-        vm.etch(SafeSingletonDeployer.SAFE_SINGLETON_FACTORY, factoryCode);
-    }
-
     function test_deploy_createsAtExpectedAddress() public {
         address expectedAddress =
             SafeSingletonDeployer.computeAddress(type(Mock).creationCode, abi.encode(1), bytes32("0x1234"));
@@ -51,4 +43,14 @@ contract SafeSingletonDeployerTest is Test {
             salt: bytes32("0x1234")
         });
     }
+
+    function test_deploy_chainWithoutFactory() public {
+        vm.chainId(1);
+        vm.expectRevert(SafeSingletonDeployer.MissingSafeSingletonFactory.selector);
+        SafeSingletonDeployer.deploy({
+            creationCode: type(Mock).creationCode,
+            args: abi.encode(1),
+            salt: bytes32("0x1234")
+        });
+    }
 }