diff --git a/.circleci/config.yml b/.circleci/config.yml
index 6689b7d4f..dc58de58b 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -52,6 +52,9 @@ jobs:
       - checkout
       - install-just
       - run: just lint-all
+      - run:
+          name: check git tree is clean
+          command: git diff --exit-code
   golang-modules-tidy:
     executor:
       name: go/default  # is based on cimg/go
diff --git a/.env.example b/.env.example
index 5d5eb0d6e..08f2addf8 100644
--- a/.env.example
+++ b/.env.example
@@ -1,6 +1,6 @@
 # Your chain must be listed in https://github.com/ethereum-lists/chains
 # And you must use the exact same name in this field:
-SCR_CHAIN_NAME=awesomechain
+SCR_CHAIN_NAME="awesomechain"
 
 # The superchain that this chain will belong to (mainnet or sepolia)
 SCR_SUPERCHAIN_TARGET=mainnet
diff --git a/add-chain/addresses.go b/add-chain/addresses.go
index 781d08213..7c56643aa 100644
--- a/add-chain/addresses.go
+++ b/add-chain/addresses.go
@@ -2,10 +2,10 @@ package main
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/BurntSushi/toml"
 	"github.com/ethereum-optimism/superchain-registry/superchain"
@@ -15,195 +15,137 @@ type AddressData struct {
 	Address string `json:"address"`
 }
 
-var (
-	// Addresses to retrieve from JSON
-	AddressManager                    = "AddressManager"
-	L1CrossDomainMessengerProxy       = "L1CrossDomainMessengerProxy"
-	L1ERC721BridgeProxy               = "L1ERC721BridgeProxy"
-	L1StandardBridgeProxy             = "L1StandardBridgeProxy"
-	OptimismMintableERC20FactoryProxy = "OptimismMintableERC20FactoryProxy"
-	SystemConfigProxy                 = "SystemConfigProxy"
-	OptimismPortalProxy               = "OptimismPortalProxy"
-	ProxyAdmin                        = "ProxyAdmin"
-
-	// Addresses to retrieve from chain
-	SuperchainConfig  = "SuperchainConfig"
-	Guardian          = "Guardian"
-	Challenger        = "Challenger"
-	ProxyAdminOwner   = "ProxyAdminOwner"
-	SystemConfigOwner = "SystemConfigOwner"
-	Proposer          = "Proposer"
-	UnsafeBlockSigner = "UnsafeBlockSigner"
-	BatchSubmitter    = "BatchSubmitter"
-
-	// Non Fault Proof contracts
-	L2OutputOracleProxy = "L2OutputOracleProxy"
-
-	// Fault Proof contracts:
-	AnchorStateRegistryProxy = "AnchorStateRegistryProxy"
-	DelayedWETHProxy         = "DelayedWETHProxy"
-	DisputeGameFactoryProxy  = "DisputeGameFactoryProxy"
-	FaultDisputeGame         = "FaultDisputeGame"
-	MIPS                     = "MIPS"
-	PermissionedDisputeGame  = "PermissionedDisputeGame"
-	PreimageOracle           = "PreimageOracle"
-)
-
-func readAddressesFromChain(addresses map[string]string, l1RpcUrl string, isFaultProofs bool) error {
+func readAddressesFromChain(addresses *superchain.AddressList, l1RpcUrl string, isFaultProofs bool) error {
 	// SuperchainConfig
-	address, err := castCall(addresses[OptimismPortalProxy], "superchainConfig()(address)", l1RpcUrl)
-	if err != nil {
-		addresses[SuperchainConfig] = ""
-	} else {
-		addresses[SuperchainConfig] = address
+	address, err := castCall(addresses.OptimismPortalProxy, "superchainConfig()(address)", l1RpcUrl)
+	if err == nil {
+		addresses.SuperchainConfig = superchain.MustHexToAddress(address)
 	}
 
 	// Guardian
-	address, err = castCall(addresses[SuperchainConfig], "guardian()(address)", l1RpcUrl)
+	address, err = castCall(addresses.SuperchainConfig, "guardian()(address)", l1RpcUrl)
 	if err != nil {
-		address, err = castCall(addresses[OptimismPortalProxy], "guardian()(address)", l1RpcUrl)
+		address, err = castCall(addresses.OptimismPortalProxy, "guardian()(address)", l1RpcUrl)
 		if err != nil {
 			return fmt.Errorf("could not retrieve address for Guardian %w", err)
 		}
 	}
-	addresses[Guardian] = address
+	addresses.Guardian = superchain.MustHexToAddress(address)
 
 	// ProxyAdminOwner
-	address, err = castCall(addresses[ProxyAdmin], "owner()(address)", l1RpcUrl)
+	address, err = castCall(addresses.ProxyAdmin, "owner()(address)", l1RpcUrl)
 	if err != nil {
 		return fmt.Errorf("could not retrieve address for ProxyAdminOwner")
 	}
-	addresses[ProxyAdminOwner] = address
+	addresses.ProxyAdminOwner = superchain.MustHexToAddress(address)
 
 	// SystemConfigOwner
-	address, err = castCall(addresses[SystemConfigProxy], "owner()(address)", l1RpcUrl)
+	address, err = castCall(addresses.SystemConfigProxy, "owner()(address)", l1RpcUrl)
 	if err != nil {
 		return fmt.Errorf("could not retrieve address for SystemConfigOwner")
 	}
-	addresses[SystemConfigOwner] = address
+	addresses.SystemConfigOwner = superchain.MustHexToAddress(address)
 
 	// UnsafeBlockSigner
-	address, err = castCall(addresses[SystemConfigProxy], "unsafeBlockSigner()(address)", l1RpcUrl)
+	address, err = castCall(addresses.SystemConfigProxy, "unsafeBlockSigner()(address)", l1RpcUrl)
 	if err != nil {
 		return fmt.Errorf("could not retrieve address for UnsafeBlockSigner")
 	}
-	addresses[UnsafeBlockSigner] = address
+	addresses.UnsafeBlockSigner = superchain.MustHexToAddress(address)
 
 	// BatchSubmitter
-	hash, err := castCall(addresses[SystemConfigProxy], "batcherHash()(bytes32)", l1RpcUrl)
+	hash, err := castCall(addresses.SystemConfigProxy, "batcherHash()(bytes32)", l1RpcUrl)
 	if err != nil {
 		return fmt.Errorf("could not retrieve batcherHash")
 	}
-	addresses[BatchSubmitter] = "0x" + hash[26:66]
+	batchSubmitter := "0x" + hash[26:66]
+	addresses.BatchSubmitter = superchain.MustHexToAddress(batchSubmitter)
 
 	if isFaultProofs {
 		// Proposer
-		address, err = castCall(addresses[PermissionedDisputeGame], "proposer()(address)", l1RpcUrl)
+		address, err = castCall(addresses.PermissionedDisputeGame, "proposer()(address)", l1RpcUrl)
 		if err != nil {
 			return fmt.Errorf("could not retrieve address for Proposer")
 		}
-		addresses[Proposer] = address
+		addresses.Proposer = superchain.MustHexToAddress(address)
 
 		// Challenger
-		address, err = castCall(addresses[PermissionedDisputeGame], "challenger()(address)", l1RpcUrl)
+		address, err = castCall(addresses.PermissionedDisputeGame, "challenger()(address)", l1RpcUrl)
 		if err != nil {
 			return fmt.Errorf("could not retrieve address for Challenger")
 		}
-		addresses[Challenger] = address
+		addresses.Challenger = superchain.MustHexToAddress(address)
 	} else {
 		// Proposer
-		address, err = castCall(addresses[L2OutputOracleProxy], "PROPOSER()(address)", l1RpcUrl)
+		address, err = castCall(addresses.L2OutputOracleProxy, "PROPOSER()(address)", l1RpcUrl)
 		if err != nil {
 			return fmt.Errorf("could not retrieve address for Proposer")
 		}
-		addresses[Proposer] = address
+		addresses.Proposer = superchain.MustHexToAddress(address)
 
 		// Challenger
-		address, err = castCall(addresses[L2OutputOracleProxy], "CHALLENGER()(address)", l1RpcUrl)
+		address, err = castCall(addresses.L2OutputOracleProxy, "CHALLENGER()(address)", l1RpcUrl)
 		if err != nil {
 			return fmt.Errorf("could not retrieve address for Challenger")
 		}
-		addresses[Challenger] = address
+		addresses.Challenger = superchain.MustHexToAddress(address)
 	}
 
 	fmt.Printf("Addresses read from chain\n")
 	return nil
 }
 
-func readAddressesFromJSON(contractAddresses map[string]string, deploymentsDir string) error {
-	contractsFromJSON := []string{
-		AddressManager,
-		L1CrossDomainMessengerProxy,
-		L1ERC721BridgeProxy,
-		L1StandardBridgeProxy,
-		OptimismMintableERC20FactoryProxy,
-		SystemConfigProxy,
-		OptimismPortalProxy,
-		ProxyAdmin,
-	}
-
-	contractsFromJSONFaultProofs := append(contractsFromJSON, []string{
-		AnchorStateRegistryProxy,
-		DelayedWETHProxy,
-		DisputeGameFactoryProxy,
-		FaultDisputeGame,
-		MIPS,
-		PermissionedDisputeGame,
-		PreimageOracle,
-	}...)
-	contractsFromJSONNonFaultProofs := append(contractsFromJSON, L2OutputOracleProxy)
-
-	contracts := contractsFromJSONFaultProofs
-
-	deployFilePath := filepath.Join(deploymentsDir, ".deploy")
-	_, err := os.Stat(deployFilePath)
-
+func readAddressesFromJSON(addressList *superchain.AddressList, deploymentsDir string) error {
+	// Check for the following
+	// 1. filepath == deploymentsDir
+	// 2. filepath == deploymentsDir/.deploy
+	// 3. filepath == deploymentsDir/<contract-name>.json
+	deployFilePath := filepath.Join(deploymentsDir)
+	fileInfo, err := os.Stat(deployFilePath)
 	if err != nil {
-		fmt.Printf("failed to find .deploy file. Will look for legacy .json files")
-		// Use legacy deployment artifact schema
+		return fmt.Errorf("invalid deployment filepath provided: %w", err)
+	}
 
-		_, err := os.ReadFile(filepath.Join(deploymentsDir, AnchorStateRegistryProxy+".json"))
-		if errors.Is(err, os.ErrNotExist) {
-			contracts = contractsFromJSONNonFaultProofs
-		}
-		for _, name := range contracts {
-			path := filepath.Join(deploymentsDir, name+".json")
-			file, err := os.ReadFile(path)
-			if err != nil {
-				return fmt.Errorf("failed to read file: %w", err)
-			}
-			var data AddressData
-			if err = json.Unmarshal(file, &data); err != nil {
-				return fmt.Errorf("failed to unmarshal json: %w", err)
-			}
-			contractAddresses[name] = data.Address
-		}
-	} else {
-		var addressList superchain.AddressList
-		rawData, err := os.ReadFile(deployFilePath)
+	if fileInfo.IsDir() {
+		deployFilePath = filepath.Join(deploymentsDir, ".deploy")
+		_, err = os.Stat(deployFilePath)
 		if err != nil {
-			return fmt.Errorf("failed to read file: %w", err)
-		}
-
-		if err = json.Unmarshal(rawData, &addressList); err != nil {
-			return fmt.Errorf("failed to unmarshal json: %w", err)
+			// Use legacy deployment artifact schema
+			contractAddresses := make(map[string]string)
+			fmt.Printf("failed to find .deploy file. Will look for legacy .json files")
+			files, _ := os.ReadDir(deploymentsDir)
+			for _, file := range files {
+				if file.IsDir() {
+					continue
+				}
+				contractName := strings.TrimSuffix(file.Name(), filepath.Ext(file.Name()))
+				fileContents, err := os.ReadFile(filepath.Join(deploymentsDir, file.Name()))
+				if err != nil {
+					return fmt.Errorf("failed to read file: %w", err)
+				}
+				var data AddressData
+				if err = json.Unmarshal(fileContents, &data); err != nil {
+					return fmt.Errorf("failed to unmarshal json: %w", err)
+				}
+				contractAddresses[contractName] = data.Address
+				err = mapToAddressList(contractAddresses, addressList)
+				if err != nil {
+					return fmt.Errorf("failed to convert contracts map into AddressList: %w", err)
+				}
+			}
+			return nil
 		}
+	}
 
-		_, err = addressList.AddressFor(AnchorStateRegistryProxy)
-		if err != nil {
-			contracts = contractsFromJSONNonFaultProofs
-		}
+	rawData, err := os.ReadFile(deployFilePath)
+	if err != nil {
+		return fmt.Errorf("failed to read file: %w", err)
+	}
 
-		for _, name := range contracts {
-			address, err := addressList.AddressFor(name)
-			if err != nil {
-				return fmt.Errorf("failed to retrieve %s address from list: %w", name, err)
-			}
-			contractAddresses[name] = address.String()
-		}
+	if err = json.Unmarshal(rawData, &addressList); err != nil {
+		return fmt.Errorf("failed to unmarshal json: %w", err)
 	}
 
-	fmt.Printf("Contract addresses read from deployments directory: %s\n", deploymentsDir)
 	return nil
 }
 
diff --git a/add-chain/e2e_test.go b/add-chain/e2e_test.go
index 973c866ca..6ac01704d 100644
--- a/add-chain/e2e_test.go
+++ b/add-chain/e2e_test.go
@@ -31,6 +31,13 @@ var tests = []struct {
 		rollupConfigFile: "./testdata/monorepo/op-node/rollup_baseline.json",
 		deploymentsDir:   "./testdata/monorepo/deployments",
 	},
+	{
+		name:             "baseline_legacy",
+		chainName:        "testchain_baseline_legacy",
+		chainShortName:   "testchain_bl",
+		rollupConfigFile: "./testdata/monorepo/op-node/rollup_baseline_legacy.json",
+		deploymentsDir:   "./testdata/monorepo/deployments-legacy",
+	},
 	{
 		name:                   "zorasep",
 		chainName:              "testchain_zorasep",
diff --git a/add-chain/go.mod b/add-chain/go.mod
index 334d2cb7b..c7ccd90cc 100644
--- a/add-chain/go.mod
+++ b/add-chain/go.mod
@@ -12,7 +12,7 @@ require (
 	github.com/google/go-cmp v0.6.0
 	github.com/joho/godotenv v1.5.1
 	github.com/stretchr/testify v1.9.0
-	github.com/urfave/cli/v2 v2.27.1
+	github.com/urfave/cli/v2 v2.27.3
 )
 
 require (
@@ -30,7 +30,7 @@ require (
 	github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect
 	github.com/consensys/bavard v0.1.13 // indirect
 	github.com/consensys/gnark-crypto v0.12.1 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
 	github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 // indirect
 	github.com/crate-crypto/go-kzg-4844 v0.7.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
@@ -78,7 +78,7 @@ require (
 	github.com/syndtr/goleveldb v1.0.1-0.20220614013038-64ee5596c38a // indirect
 	github.com/tklauser/go-sysconf v0.3.12 // indirect
 	github.com/tklauser/numcpus v0.6.1 // indirect
-	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
+	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
 	github.com/yusufpapurcu/wmi v1.2.3 // indirect
 	golang.org/x/crypto v0.23.0 // indirect
 	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect
diff --git a/add-chain/go.sum b/add-chain/go.sum
index 7b02cfa58..972d9fffd 100644
--- a/add-chain/go.sum
+++ b/add-chain/go.sum
@@ -41,8 +41,8 @@ github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/Yj
 github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI=
 github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M=
 github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY=
-github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
-github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ=
 github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs=
 github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA=
@@ -225,10 +225,10 @@ github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+F
 github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY=
 github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
 github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
-github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=
-github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
+github.com/urfave/cli/v2 v2.27.3 h1:/POWahRmdh7uztQ3CYnaDddk0Rm90PyOgIxgW2rr41M=
+github.com/urfave/cli/v2 v2.27.3/go.mod h1:m4QzxcD2qpra4z7WhzEGn74WZLViBnMpb1ToCAKdGRQ=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw=
diff --git a/add-chain/main.go b/add-chain/main.go
index 8a9f84e9d..3930d5ae9 100644
--- a/add-chain/main.go
+++ b/add-chain/main.go
@@ -123,13 +123,13 @@ func entrypoint(ctx *cli.Context) error {
 		return fmt.Errorf("failed to retrieve L1 rpc url: %w", err)
 	}
 
-	addresses := make(map[string]string)
-	err = readAddressesFromJSON(addresses, deploymentsDir)
+	var addresses superchain.AddressList
+	err = readAddressesFromJSON(&addresses, deploymentsDir)
 	if err != nil {
 		return fmt.Errorf("failed to read addresses from JSON files: %w", err)
 	}
 
-	isFaultProofs, err := inferIsFaultProofs(addresses["OptimismPortalProxy"], l1RpcUrl)
+	isFaultProofs, err := inferIsFaultProofs(addresses.SystemConfigProxy, addresses.OptimismPortalProxy, l1RpcUrl)
 	if err != nil {
 		return fmt.Errorf("failed to infer fault proofs status of chain: %w", err)
 	}
@@ -139,27 +139,22 @@ func entrypoint(ctx *cli.Context) error {
 		return fmt.Errorf("failed to construct rollup config: %w", err)
 	}
 
-	err = readAddressesFromChain(addresses, l1RpcUrl, isFaultProofs)
+	err = readAddressesFromChain(&addresses, l1RpcUrl, isFaultProofs)
 	if err != nil {
 		return fmt.Errorf("failed to read addresses from chain: %w", err)
 	}
 
 	if rollupConfig.Plasma != nil {
-		addresses["DAChallengeAddress"] = rollupConfig.Plasma.DAChallengeAddress.String()
+		addresses.DAChallengeAddress = *rollupConfig.Plasma.DAChallengeAddress
 	}
 
-	addressList := superchain.AddressList{}
-	err = mapToAddressList(addresses, &addressList)
-	if err != nil {
-		return fmt.Errorf("error converting map to AddressList: %w", err)
-	}
-	rollupConfig.Addresses = addressList
+	rollupConfig.Addresses = addresses
 
 	l1RpcUrl, err = config.GetL1RpcUrl(superchainTarget)
 	if err != nil {
 		return fmt.Errorf("error getting l1RpcUrl: %w", err)
 	}
-	gpt, err := getGasPayingToken(l1RpcUrl, addressList.SystemConfigProxy)
+	gpt, err := getGasPayingToken(l1RpcUrl, addresses.SystemConfigProxy)
 	if err != nil {
 		return fmt.Errorf("error inferring gas paying token: %w", err)
 	}
@@ -175,7 +170,15 @@ func entrypoint(ctx *cli.Context) error {
 	return nil
 }
 
-func inferIsFaultProofs(optimismPortalProxyAddress, l1RpcUrl string) (bool, error) {
+func inferIsFaultProofs(systemConfigProxyAddress, optimismPortalProxyAddress superchain.Address, l1RpcUrl string) (bool, error) {
+	tokenAddress, err := getGasPayingToken(l1RpcUrl, systemConfigProxyAddress)
+	if err != nil {
+		return false, fmt.Errorf("failed to query for gasPayingToken: %w", err)
+	}
+	if tokenAddress != nil {
+		return false, nil
+	}
+
 	// Portal version `3` is the first version of the `OptimismPortal` that supported the fault proof system.
 	version, err := castCall(optimismPortalProxyAddress, "version()(string)", l1RpcUrl)
 	if err != nil {
@@ -190,6 +193,7 @@ func inferIsFaultProofs(optimismPortalProxyAddress, l1RpcUrl string) (bool, erro
 	if err != nil {
 		return false, fmt.Errorf("failed to parse OptimismPortalProxy.version(): %w", err)
 	}
+
 	return majorVersion >= 3, nil
 }
 
@@ -205,14 +209,12 @@ func getGasPayingToken(l1rpcURl string, SystemConfigAddress superchain.Address)
 
 	opts := bind.CallOpts{}
 	result, err := sc.GasPayingToken(&opts)
-
-	if strings.Contains(err.Error(), "execution reverted") {
-		// This happens when the SystemConfig contract
-		// does not yet have the CGT functionality.
-		return nil, nil
-	}
-
 	if err != nil {
+		if strings.Contains(err.Error(), "execution reverted") {
+			// This happens when the SystemConfig contract
+			// does not yet have the CGT functionality.
+			return nil, nil
+		}
 		return nil, err
 	}
 
diff --git a/add-chain/testdata/monorepo/deployments-legacy/AddressManager.json b/add-chain/testdata/monorepo/deployments-legacy/AddressManager.json
new file mode 100644
index 000000000..b80eab5de
--- /dev/null
+++ b/add-chain/testdata/monorepo/deployments-legacy/AddressManager.json
@@ -0,0 +1,3 @@
+{
+  "address": 	"0xBBCfC68f590ae60Feb1551F4C639E3Eab5ea7BA9"
+}
diff --git a/add-chain/testdata/monorepo/deployments-legacy/L1CrossDomainMessengerProxy.json b/add-chain/testdata/monorepo/deployments-legacy/L1CrossDomainMessengerProxy.json
new file mode 100644
index 000000000..1b2bb79bf
--- /dev/null
+++ b/add-chain/testdata/monorepo/deployments-legacy/L1CrossDomainMessengerProxy.json
@@ -0,0 +1,3 @@
+{
+  "address": 	"0x6b95418119Aa1bc41D521377D98E6c367817A755"
+}
diff --git a/add-chain/testdata/monorepo/deployments-legacy/L1ERC721BridgeProxy.json b/add-chain/testdata/monorepo/deployments-legacy/L1ERC721BridgeProxy.json
new file mode 100644
index 000000000..d0627d0ec
--- /dev/null
+++ b/add-chain/testdata/monorepo/deployments-legacy/L1ERC721BridgeProxy.json
@@ -0,0 +1,3 @@
+{
+  "address": 	"0x460Cb843a61CeB6cFB3BC3373FC405744f5be4ee"
+}
diff --git a/add-chain/testdata/monorepo/deployments-legacy/L1StandardBridgeProxy.json b/add-chain/testdata/monorepo/deployments-legacy/L1StandardBridgeProxy.json
new file mode 100644
index 000000000..7c6ea0508
--- /dev/null
+++ b/add-chain/testdata/monorepo/deployments-legacy/L1StandardBridgeProxy.json
@@ -0,0 +1,3 @@
+{
+  "address": 	"0xC4Ed1Ae4671B38A44B3cea27E1F7462cFe6B1A87"
+}
diff --git a/add-chain/testdata/monorepo/deployments-legacy/L2OutputOracleProxy.json b/add-chain/testdata/monorepo/deployments-legacy/L2OutputOracleProxy.json
new file mode 100644
index 000000000..a7b2721d7
--- /dev/null
+++ b/add-chain/testdata/monorepo/deployments-legacy/L2OutputOracleProxy.json
@@ -0,0 +1,3 @@
+{
+  "address": 	"0x3F8A862E63E759a77DA22d384027D21BF096bA9E"
+}
diff --git a/add-chain/testdata/monorepo/deployments-legacy/OptimismMintableERC20FactoryProxy.json b/add-chain/testdata/monorepo/deployments-legacy/OptimismMintableERC20FactoryProxy.json
new file mode 100644
index 000000000..faed7262e
--- /dev/null
+++ b/add-chain/testdata/monorepo/deployments-legacy/OptimismMintableERC20FactoryProxy.json
@@ -0,0 +1,3 @@
+{
+  "address": 	"0x39f10A94B969587A2f1739b4AbE3b223814D2A07"
+}
diff --git a/add-chain/testdata/monorepo/deployments-legacy/OptimismPortalProxy.json b/add-chain/testdata/monorepo/deployments-legacy/OptimismPortalProxy.json
new file mode 100644
index 000000000..c84ba21da
--- /dev/null
+++ b/add-chain/testdata/monorepo/deployments-legacy/OptimismPortalProxy.json
@@ -0,0 +1,3 @@
+{
+  "address": 	"0x6C84AE91901CE8a4897187c33A0094a6e790f34d"
+}
diff --git a/add-chain/testdata/monorepo/deployments-legacy/ProxyAdmin.json b/add-chain/testdata/monorepo/deployments-legacy/ProxyAdmin.json
new file mode 100644
index 000000000..af3da0970
--- /dev/null
+++ b/add-chain/testdata/monorepo/deployments-legacy/ProxyAdmin.json
@@ -0,0 +1,3 @@
+{
+  "address": 	"0xd3fE61dd95c1e148A6ef540e1D4983d62726661C"
+}
diff --git a/add-chain/testdata/monorepo/deployments-legacy/SystemConfigProxy.json b/add-chain/testdata/monorepo/deployments-legacy/SystemConfigProxy.json
new file mode 100644
index 000000000..dccddb9d1
--- /dev/null
+++ b/add-chain/testdata/monorepo/deployments-legacy/SystemConfigProxy.json
@@ -0,0 +1,3 @@
+{
+  "address": 	"0x8787D3382F60d4e072b4276BBda065959195dB33"
+}
diff --git a/add-chain/testdata/monorepo/op-node/rollup_baseline_legacy.json b/add-chain/testdata/monorepo/op-node/rollup_baseline_legacy.json
new file mode 100644
index 000000000..efbe7e5d8
--- /dev/null
+++ b/add-chain/testdata/monorepo/op-node/rollup_baseline_legacy.json
@@ -0,0 +1,34 @@
+{
+  "genesis": {
+    "l1": {
+      "hash": "0x1fc104fe244042459314bc1d51a230320c64a3d47cd06b7998aa3f57b9b0fc79",
+      "number": 5753349
+    },
+    "l2": {
+      "hash": "0x0ceefff2113580e4d665c324661e4982a824025bf97285cf09a52715b6f89083",
+      "number": 0
+    },
+    "l2_time": 1713792864,
+    "system_config": {
+      "batcherAddr": "0x27bf581015c64ec7c57c6e7b3117f35b5f6dd706",
+      "overhead": "0x0000000000000000000000000000000000000000000000000000000000000834",
+      "scalar": "0x00000000000000000000000000000000000000000000000000000000000f4240",
+      "gasLimit": 30000000,
+      "baseFeeScalar": 0,
+      "blobBaseFeeScalar": 0
+    }
+  },
+  "block_time": 2,
+  "max_sequencer_drift": 600,
+  "seq_window_size": 3600,
+  "channel_timeout": 300,
+  "l1_chain_id": 11155111,
+  "l2_chain_id": 4206905,
+  "regolith_time": 0,
+  "canyon_time": 0,
+  "delta_time": 1703203200,
+  "batch_inbox_address": "0xff00000000000000000000000000000000042069",
+  "deposit_contract_address": "0x6c84ae91901ce8a4897187c33a0094a6e790f34d",
+  "l1_system_config_address": "0x8787d3382f60d4e072b4276bbda065959195db33",
+  "protocol_versions_address": "0x0000000000000000000000000000000000000000"
+}
diff --git a/add-chain/testdata/superchain/configs/sepolia/expected_baseline_legacy.toml b/add-chain/testdata/superchain/configs/sepolia/expected_baseline_legacy.toml
new file mode 100644
index 000000000..e18623290
--- /dev/null
+++ b/add-chain/testdata/superchain/configs/sepolia/expected_baseline_legacy.toml
@@ -0,0 +1,47 @@
+name = "testchain_baseline_legacy"
+chain_id = 4206905
+public_rpc = "http://awe.some.rpc"
+sequencer_rpc = "http://awe.some.seq.rpc"
+explorer = "https://awesomescan.org"
+superchain_level = 1
+batch_inbox_addr = "0xFf00000000000000000000000000000000042069"
+canyon_time = 0 # Thu 1 Jan 1970 00:00:00 UTC
+delta_time = 1703203200 # Fri 22 Dec 2023 00:00:00 UTC
+block_time = 2
+seq_window_size = 3600
+data_availability_type = "eth-da"
+
+[genesis]
+  l2_time = 1713792864
+  [genesis.l1]
+    hash = "0x1fc104fe244042459314bc1d51a230320c64a3d47cd06b7998aa3f57b9b0fc79"
+    number = 5753349
+  [genesis.l2]
+    hash = "0x0ceefff2113580e4d665c324661e4982a824025bf97285cf09a52715b6f89083"
+    number = 0
+  [genesis.system_config]
+    batcherAddress = "0x27bf581015C64ec7C57C6E7b3117F35B5f6Dd706"
+    overhead = "0x0000000000000000000000000000000000000000000000000000000000000834"
+    scalar = "0x00000000000000000000000000000000000000000000000000000000000f4240"
+    gasLimit = 30000000
+    baseFeeScalar = 0
+    blobBaseFeeScalar = 0
+
+[addresses]
+  SystemConfigOwner = "0xe8D525b30dD4C406570d47396b5b237DB30F13F1"
+  ProxyAdminOwner = "0x9663FF52F1666954551460FcF190b4E3DaECab37"
+  Guardian = "0xe8D525b30dD4C406570d47396b5b237DB30F13F1"
+  Challenger = "0xe8D525b30dD4C406570d47396b5b237DB30F13F1"
+  Proposer = "0x1F191527d46E4F8FE7BFdBb74b442941C1305E44"
+  UnsafeBlockSigner = "0x9431B143448A60A374ab196d0d7C0683c5369006"
+  BatchSubmitter = "0x5e80C486D66f51F4933EF04D61b8c4429eA01DB3"
+  AddressManager = "0xBBCfC68f590ae60Feb1551F4C639E3Eab5ea7BA9"
+  L1CrossDomainMessengerProxy = "0x6b95418119Aa1bc41D521377D98E6c367817A755"
+  L1ERC721BridgeProxy = "0x460Cb843a61CeB6cFB3BC3373FC405744f5be4ee"
+  L1StandardBridgeProxy = "0xC4Ed1Ae4671B38A44B3cea27E1F7462cFe6B1A87"
+  L2OutputOracleProxy = "0x3F8A862E63E759a77DA22d384027D21BF096bA9E"
+  OptimismMintableERC20FactoryProxy = "0x39f10A94B969587A2f1739b4AbE3b223814D2A07"
+  OptimismPortalProxy = "0x6C84AE91901CE8a4897187c33A0094a6e790f34d"
+  SystemConfigProxy = "0x8787D3382F60d4e072b4276BBda065959195dB33"
+  ProxyAdmin = "0xd3fE61dd95c1e148A6ef540e1D4983d62726661C"
+  SuperchainConfig = "0xdf69B06cEB4A4b4Db3CC288840435e673ac4d893"
diff --git a/add-chain/utils.go b/add-chain/utils.go
index 077b82ed3..910749976 100644
--- a/add-chain/utils.go
+++ b/add-chain/utils.go
@@ -5,10 +5,12 @@ import (
 	"fmt"
 	"os/exec"
 	"strings"
+
+	"github.com/ethereum-optimism/superchain-registry/superchain"
 )
 
-func castCall(contractAddress, calldata, l1RpcUrl string) (string, error) {
-	cmd := exec.Command("cast", "call", contractAddress, calldata, "-r", l1RpcUrl)
+func castCall(contractAddress superchain.Address, calldata, l1RpcUrl string) (string, error) {
+	cmd := exec.Command("cast", "call", contractAddress.String(), calldata, "-r", l1RpcUrl)
 	var out bytes.Buffer
 	var stderr bytes.Buffer
 	cmd.Stdout = &out
diff --git a/superchain/init.go b/superchain/init.go
index 3c9004093..79791387e 100644
--- a/superchain/init.go
+++ b/superchain/init.go
@@ -73,24 +73,24 @@ func init() {
 			GenesisSystemConfigs[chainConfig.ChainID] = &chainConfig.Genesis.SystemConfig
 		}
 
-    // Impute endpoints only if we're not in codegen mode.
-    if os.Getenv("CODEGEN") == "" {
-      ciMainnetRPC := os.Getenv("CIRCLE_CI_MAINNET_RPC")
-		  ciSepoliaRPC := os.Getenv("CIRCLE_CI_SEPOLIA_RPC")
+		// Impute endpoints only if we're not in codegen mode.
+		if os.Getenv("CODEGEN") == "" {
+			ciMainnetRPC := os.Getenv("CIRCLE_CI_MAINNET_RPC")
+			ciSepoliaRPC := os.Getenv("CIRCLE_CI_SEPOLIA_RPC")
 
-      switch superchainEntry.Superchain {
-      case "mainnet":
-        if ciMainnetRPC != "" {
-          fmt.Println("Using env var for mainnet rpc")
-          superchainEntry.Config.L1.PublicRPC = ciMainnetRPC
-        }
-      case "sepolia", "sepolia-dev-0":
-        if ciSepoliaRPC != "" {
-          fmt.Println("Using env var for sepolia rpc")
-          superchainEntry.Config.L1.PublicRPC = ciSepoliaRPC
-        }
-      }
-    }
+			switch superchainEntry.Superchain {
+			case "mainnet":
+				if ciMainnetRPC != "" {
+					fmt.Println("Using env var for mainnet rpc")
+					superchainEntry.Config.L1.PublicRPC = ciMainnetRPC
+				}
+			case "sepolia", "sepolia-dev-0":
+				if ciSepoliaRPC != "" {
+					fmt.Println("Using env var for sepolia rpc")
+					superchainEntry.Config.L1.PublicRPC = ciSepoliaRPC
+				}
+			}
+		}
 
 		Superchains[superchainEntry.Superchain] = &superchainEntry
 	}
diff --git a/validation/gas-token_test.go b/validation/gas-token_test.go
index 1dff91769..084f582cd 100644
--- a/validation/gas-token_test.go
+++ b/validation/gas-token_test.go
@@ -68,8 +68,8 @@ func getBytes(method string, contractAddress Address, client *ethclient.Client)
 
 	return Retry(callContract)(callMsg)
 }
-func getHexString(method string, contractAddress Address, client *ethclient.Client) (string, error) {
 
+func getHexString(method string, contractAddress Address, client *ethclient.Client) (string, error) {
 	result, err := getBytes(method, contractAddress, client)
 
 	return common.Bytes2Hex(result), err