Convert add-chain.sh into a go package

.circleci/config.yml

@@ -24,7 +24,7 @@ jobs:
       tag: '1.21'
     steps:
       - checkout
-      - run:  golangci-lint run superchain/... validation/...
+      - run:  golangci-lint run superchain/... validation/... add-chain/...
   golang-modules-tidy:
     executor:
       name: go/default  # is based on cimg/go
@@ -39,15 +39,36 @@ jobs:
           name: tidy validation module
           command: go mod tidy
           working_directory: validation
+      - run:
+          name: tidy add-chain module
+          command: go mod tidy
+          working_directory: add-chain
       - run:
           name: check git tree is clean
           command: git diff --exit-code
   golang-test:
+    shell: /bin/bash -eo pipefail
     executor:
       name: go/default  # is based on cimg/go
       tag: '1.21'
     steps:
       - checkout
+      - run:
+          # need foundry to execute 'cast call' within add-chain script
+          name: Install foundry
+          command: |
+            echo "SHELL=$SHELL"
+            # Set up directory structure
+            mkdir -p $HOME/.foundry/bin
+            echo 'export PATH="$HOME/.foundry/bin:$PATH"' >> $BASH_ENV
+            source $BASH_ENV
+
+            # Download foundryup and make it executable
+            curl -sSL "https://raw.githubusercontent.com/foundry-rs/foundry/master/foundryup/foundryup" -o $HOME/.foundry/bin/foundryup
+            chmod +x $HOME/.foundry/bin/foundryup
+
+            $HOME/.foundry/bin/foundryup
+            forge --version
       - run:
           name: run superchain module tests
           command: go test ./... -v
@@ -56,6 +77,10 @@ jobs:
           name: run validation module tests
           command: go test ./... -v
           working_directory: validation
+      - run:
+          name: run add-chain module tests
+          command: go test ./... -v
+          working_directory: add-chain
       - notify-failures-on-main
   publish-bot:
     environment:
@@ -101,7 +126,7 @@ jobs:
       - run:
           name: check security configs
           command: sh ./scripts/check-security-configs.sh
-      - notify-failures-on-main    
+      - notify-failures-on-main
 
 workflows:
   hourly:

.gitignore

@@ -21,6 +21,7 @@ docs/
 .env
 .env*
 !.env.example
+!.env.test
 *.log
 
 

add-chain/.gitignore

@@ -0,0 +1,2 @@
+# test output artifacts
+testdata/**/awesomechain*

add-chain/chain_config.go

@@ -0,0 +1,121 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/ethereum-optimism/superchain-registry/superchain"
+	"gopkg.in/yaml.v3"
+)
+
+// constructRollupConfig creates and populates a ChainConfig struct by reading from an input file and
+// explicitly setting some additional fields to input argument values
+func constructRollupConfig(inputFilePath, chainName, publicRPC, sequencerRPC, explorer string, superchainLevel superchain.SuperchainLevel) (superchain.ChainConfig, error) {
+	fmt.Printf("Attempting to read from %s\n", inputFilePath)
+	file, err := os.ReadFile(inputFilePath)
+	if err != nil {
+		return superchain.ChainConfig{}, fmt.Errorf("error reading file: %w", err)
+	}
+	var config superchain.ChainConfig
+	if err = json.Unmarshal(file, &config); err != nil {
+		return superchain.ChainConfig{}, fmt.Errorf("error unmarshaling json: %w", err)
+	}
+
+	config.Name = chainName
+	config.PublicRPC = publicRPC
+	config.SequencerRPC = sequencerRPC
+	config.SuperchainLevel = superchainLevel
+	config.Explorer = explorer
+
+	fmt.Printf("Rollup config successfully constructed\n")
+	return config, nil
+}
+
+// writeChainConfig accepts a rollupConfig, formats it, and writes some output files based on the given
+// target directories
+func writeChainConfig(
+	rollupConfig superchain.ChainConfig,
+	targetDirectory string,
+	superchainRepoPath string,
+	superchainTarget string,
+) error {
+	// Create genesis-system-config data
+	// (this is deprecated, users should load this from L1, when available via SystemConfig)
+	dirPath := filepath.Join(superchainRepoPath, "superchain", "extra", "genesis-system-configs", superchainTarget)
+
+	if err := os.MkdirAll(dirPath, 0o755); err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+
+	systemConfigJSON, err := json.MarshalIndent(rollupConfig.Genesis.SystemConfig, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal genesis system config json: %w", err)
+	}
+
+	// Write the genesis system config JSON to a new file
+	filePath := filepath.Join(dirPath, rollupConfig.Name+".json")
+	if err := os.WriteFile(filePath, systemConfigJSON, 0o644); err != nil {
+		return fmt.Errorf("failed to write genesis system config json: %w", err)
+	}
+	fmt.Printf("Genesis system config written to: %s\n", filePath)
+
+	rollupConfig.Genesis.SystemConfig = superchain.SystemConfig{} // remove SystemConfig so its omitted from yaml
+
+	// Remove hardfork timestamp override fields if they match superchain defaults
+	defaults := superchain.Superchains[superchainTarget]
+	rollupConfig.SetDefaultHardforkTimestampsToNil(&defaults.Config)
+
+	yamlData, err := yaml.Marshal(rollupConfig)
+	if err != nil {
+		return fmt.Errorf("failed to marshal yaml: %w", err)
+	}
+
+	// Unmarshal bytes into a yaml.Node for custom manipulation
+	var rootNode yaml.Node
+	if err = yaml.Unmarshal(yamlData, &rootNode); err != nil {
+		return err
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err = rollupConfig.EnhanceYAML(ctx, &rootNode); err != nil {
+		return err
+	}
+
+	// Write the rollup config to a yaml file
+	filename := filepath.Join(targetDirectory)
+	file, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	encoder := yaml.NewEncoder(file)
+	defer encoder.Close()
+
+	encoder.SetIndent(2)
+	if err := encoder.Encode(&rootNode); err != nil {
+		return fmt.Errorf("failed to write yaml file: %w", err)
+	}
+
+	fmt.Printf("Rollup config written to: %s\n", filename)
+	return nil
+}
+
+func getL1RpcUrl(superchainTarget string) (string, error) {
+	superChain, ok := superchain.Superchains[superchainTarget]
+	if !ok {
+		return "", fmt.Errorf("unknown superchain target provided: %s", superchainTarget)
+	}
+
+	if superChain.Config.L1.PublicRPC == "" {
+		return "", fmt.Errorf("missing L1 public rpc endpoint in superchain config")
+	}
+
+	fmt.Printf("Setting L1 public rpc endpoint to %s\n", superChain.Config.L1.PublicRPC)
+	return superChain.Config.L1.PublicRPC, nil
+}

add-chain/contract_addresses.go

@@ -0,0 +1,160 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/ethereum-optimism/superchain-registry/superchain"
+)
+
+type AddressData struct {
+	Address string `json:"address"`
+}
+
+var (
+	// Addresses to retrieve from JSON
+	AddressManager                    = "AddressManager"
+	L1CrossDomainMessengerProxy       = "L1CrossDomainMessengerProxy"
+	L1ERC721BridgeProxy               = "L1ERC721BridgeProxy"
+	L1StandardBridgeProxy             = "L1StandardBridgeProxy"
+	L2OutputOracleProxy               = "L2OutputOracleProxy"
+	OptimismMintableERC20FactoryProxy = "OptimismMintableERC20FactoryProxy"
+	SystemConfigProxy                 = "SystemConfigProxy"
+	OptimismPortalProxy               = "OptimismPortalProxy"
+	ProxyAdmin                        = "ProxyAdmin"
+
+	// Addresses to retrieve from chain
+	SuperchainConfig  = "SuperchainConfig"
+	Guardian          = "Guardian"
+	Challenger        = "Challenger"
+	ProxyAdminOwner   = "ProxyAdminOwner"
+	SystemConfigOwner = "SystemConfigOwner"
+)
+
+func readAddressesFromChain(contractAddresses map[string]string, l1RpcUrl string) error {
+	// SuperchainConfig
+	address, err := castCall(contractAddresses[OptimismPortalProxy], "superchainConfig()(address)", l1RpcUrl)
+	if err != nil {
+		contractAddresses[SuperchainConfig] = ""
+	} else {
+		contractAddresses[SuperchainConfig] = address
+	}
+
+	// Guardian
+	address, err = castCall(contractAddresses[SuperchainConfig], "guardian()(address)", l1RpcUrl)
+	if err != nil {
+		address, err = castCall(contractAddresses[OptimismPortalProxy], "guardian()(address)", l1RpcUrl)
+		if err != nil {
+			return fmt.Errorf("could not retrieve address for Guardian %w", err)
+		}
+	}
+	contractAddresses[Guardian] = address
+
+	// Challenger
+	address, err = castCall(contractAddresses[L2OutputOracleProxy], "challenger()(address)", l1RpcUrl)
+	if err != nil {
+		return fmt.Errorf("could not retrieve address for Guardian")
+	}
+	contractAddresses[Challenger] = address
+
+	// ProxyAdminOwner
+	address, err = castCall(contractAddresses[ProxyAdmin], "owner()(address)", l1RpcUrl)
+	if err != nil {
+		return fmt.Errorf("could not retrieve address for ProxyAdminOwner")
+	}
+	contractAddresses[ProxyAdminOwner] = address
+
+	// SystemConfigOwner
+	address, err = castCall(contractAddresses[SystemConfigProxy], "owner()(address)", l1RpcUrl)
+	if err != nil {
+		return fmt.Errorf("could not retrieve address for ProxyAdminOwner")
+	}
+	contractAddresses[SystemConfigOwner] = address
+
+	fmt.Printf("Contract addresses read from on-chain contracts\n")
+	return nil
+}
+
+func readAddressesFromJSON(contractAddresses map[string]string, deploymentsDir string) error {
+	contractsFromJSON := []string{
+		AddressManager,
+		L1CrossDomainMessengerProxy,
+		L1ERC721BridgeProxy,
+		L1StandardBridgeProxy,
+		L2OutputOracleProxy,
+		OptimismMintableERC20FactoryProxy,
+		SystemConfigProxy,
+		OptimismPortalProxy,
+		ProxyAdmin,
+	}
+
+	deployFilePath := filepath.Join(deploymentsDir, ".deploy")
+	_, err := os.Stat(deployFilePath)
+
+	if err != nil {
+		// Use legacy deployment artifact schema
+		for _, name := range contractsFromJSON {
+			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 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)
+		}
+
+		for _, name := range contractsFromJSON {
+			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()
+		}
+	}
+
+	fmt.Printf("Contract addresses read from deployments directory: %s\n", deploymentsDir)
+	return nil
+}
+
+func writeAddressesToJSON(contractsAddresses map[string]string, superchainRepoPath, target, chainName string) error {
+	dirPath := filepath.Join(superchainRepoPath, "superchain", "extra", "addresses", target)
+	if err := os.MkdirAll(dirPath, 0o755); err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+
+	filePath := filepath.Join(dirPath, chainName+".json")
+	file, err := os.Create(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to create file: %w", err)
+	}
+	defer file.Close()
+
+	// Marshal the map to JSON
+	jsonData, err := json.MarshalIndent(contractsAddresses, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal json: %w", err)
+	}
+
+	// Write the JSON data to the file
+	if _, err := file.Write(jsonData); err != nil {
+		return fmt.Errorf("failed to write json to file: %w", err)
+	}
+	fmt.Printf("Contract addresses written to: %s\n", filePath)
+
+	return nil
+}