Refactor BindGen E2E tests (#8741)

.circleci/config.yml

@@ -524,16 +524,16 @@ jobs:
           working_directory: op-bindings
       - notify-failures-on-develop
 
-  bindgen-test:
+  bindgen-test-e2e:
     docker:
       - image: <<pipeline.parameters.ci_builder_image>>
     resource_class: xlarge
     steps:
       - checkout
       - run:
-          name: bindgen test
+          name: bindgen test E2E
           command: make test-bindgen-e2e
-          working_directory: op-bindings
+          working_directory: op-bindings-e2e
       - notify-failures-on-develop
 
   js-lint-test:
@@ -2012,7 +2012,7 @@ workflows:
           context:
             - slack
             - oplabs-etherscan
-      - bindgen-test:
+      - bindgen-test-e2e:
           context:
             - slack
             - oplabs-etherscan

op-bindings-e2e/Makefile

+test-bindgen-e2e:
+	go test ./... -count=1
\ No newline at end of file

op-bindings-e2e/remote_handlers_test.go

+package bindgen
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindgen"
+	"github.com/ethereum-optimism/optimism/op-bindings/etherscan"
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+var generator bindgen.BindGenGeneratorRemote = bindgen.BindGenGeneratorRemote{}
+
+func configureGenerator(t *testing.T) error {
+	generator.ContractDataClients.Eth = etherscan.NewEthereumClient(os.Getenv("ETHERSCAN_APIKEY_ETH"))
+	generator.ContractDataClients.Op = etherscan.NewOptimismClient(os.Getenv("ETHERSCAN_APIKEY_OP"))
+
+	var err error
+	if generator.RpcClients.Eth, err = ethclient.Dial(os.Getenv("RPC_URL_ETH")); err != nil {
+		return fmt.Errorf("error initializing Ethereum client: %w", err)
+	}
+	if generator.RpcClients.Op, err = ethclient.Dial(os.Getenv("RPC_URL_OP")); err != nil {
+		return fmt.Errorf("error initializing Optimism client: %w", err)
+	}
+
+	return nil
+}
+
+func TestFetchContractData(t *testing.T) {
+	if err := configureGenerator(t); err != nil {
+		t.Error(err)
+	}
+
+	for _, tt := range fetchContractDataTests {
+		t.Run(tt.name, func(t *testing.T) {
+			contractData, err := generator.FetchContractData(tt.contractVerified, tt.chain, tt.deploymentAddress)
+			if err != nil {
+				t.Error(err)
+			}
+			if !reflect.DeepEqual(contractData, tt.expectedContractData) {
+				t.Errorf("Retrieved contract data doesn't match expected. Expected: %s Retrieved: %s", tt.expectedContractData, contractData)
+			}
+		})
+	}
+}
+
+func TestFetchContractDataFailures(t *testing.T) {
+	if err := configureGenerator(t); err != nil {
+		t.Error(err)
+	}
+
+	for _, tt := range fetchContractDataTestsFailures {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := generator.FetchContractData(tt.contractVerified, tt.chain, tt.deploymentAddress)
+			if err == nil {
+				t.Errorf("Expected error: %s but didn't receive it", tt.expectedError)
+				return
+			}
+
+			if !strings.Contains(err.Error(), tt.expectedError) {
+				t.Errorf("Expected error: %s Received: %s", tt.expectedError, err)
+				return
+			}
+		})
+	}
+}
+
+func TestCompareInitBytecodeWithOp(t *testing.T) {
+	if err := configureGenerator(t); err != nil {
+		t.Error(err)
+	}
+
+	for _, tt := range compareInitBytecodeWithOpTests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := generator.CompareInitBytecodeWithOp(&tt.contractMetadataEth, tt.initCodeShouldMatch)
+			if err != nil {
+				t.Error(err)
+			}
+		})
+	}
+}
+
+func TestCompareInitBytecodeWithOpFailures(t *testing.T) {
+	if err := configureGenerator(t); err != nil {
+		t.Error(err)
+	}
+
+	for _, tt := range compareInitBytecodeWithOpTestsFailures {
+		t.Run(tt.name, func(t *testing.T) {
+			err := generator.CompareInitBytecodeWithOp(&tt.contractMetadataEth, tt.initCodeShouldMatch)
+			if err == nil {
+				t.Errorf("Expected error: %s but didn't receive it", tt.expectedError)
+				return
+			}
+
+			if !strings.Contains(err.Error(), tt.expectedError) {
+				t.Errorf("Expected error: %s Received: %s", tt.expectedError, err)
+				return
+			}
+		})
+	}
+}
+
+func TestCompareDeployedBytecodeWithOp(t *testing.T) {
+	if err := configureGenerator(t); err != nil {
+		t.Error(err)
+	}
+
+	for _, tt := range compareDeployedBytecodeWithOpTests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := generator.CompareDeployedBytecodeWithOp(&tt.contractMetadataEth, tt.deployedCodeShouldMatch)
+			if err != nil {
+				t.Error(err)
+			}
+		})
+	}
+}
+
+func TestCompareDeployedBytecodeWithOpFailures(t *testing.T) {
+	if err := configureGenerator(t); err != nil {
+		t.Error(err)
+	}
+
+	for _, tt := range compareDeployedBytecodeWithOpTestsFailures {
+		t.Run(tt.name, func(t *testing.T) {
+			err := generator.CompareDeployedBytecodeWithOp(&tt.contractMetadataEth, tt.deployedCodeShouldMatch)
+			if err == nil {
+				t.Errorf("Expected error: %s but didn't receive it", tt.expectedError)
+				return
+			}
+
+			if !strings.Contains(err.Error(), tt.expectedError) {
+				t.Errorf("Expected error: %s Received: %s", tt.expectedError, err)
+				return
+			}
+		})
+	}
+}
+
+func TestCompareDeployedBytecodeWithRpc(t *testing.T) {
+	if err := configureGenerator(t); err != nil {
+		t.Error(err)
+	}
+
+	for _, tt := range compareDeployedBytecodeWithRpcTests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := generator.CompareDeployedBytecodeWithRpc(&tt.contractMetadataEth, tt.chain)
+			if err != nil {
+				t.Error(err)
+			}
+		})
+	}
+}
+
+func TestCompareDeployedBytecodeWithRpcFailures(t *testing.T) {
+	if err := configureGenerator(t); err != nil {
+		t.Error(err)
+	}
+
+	for _, tt := range compareDeployedBytecodeWithRpcTestsFailures {
+		t.Run(tt.name, func(t *testing.T) {
+			err := generator.CompareDeployedBytecodeWithRpc(&tt.contractMetadataEth, tt.chain)
+			if err == nil {
+				t.Errorf("Expected error: %s but didn't receive it", tt.expectedError)
+				return
+			}
+
+			if !strings.Contains(err.Error(), tt.expectedError) {
+				t.Errorf("Expected error: %s Received: %s", tt.expectedError, err)
+				return
+			}
+		})
+	}
+}

op-bindings/Makefile

@@ -28,7 +28,7 @@ bindings-build: bindgen-generate-local
 bindgen: compile bindgen-generate-all
 
 bindgen-generate-all:
-	go run ./bindgen/ \
+	go run ./cmd/ \
 		generate \
 		--metadata-out ./$(pkg) \
 		--bindings-package $(pkg) \
@@ -45,7 +45,7 @@ bindgen-generate-all:
 bindgen-local: compile bindgen-generate-local
 
 bindgen-generate-local:
-	go run ./bindgen/ \
+	go run ./cmd/ \
 		generate \
 		--metadata-out ./$(pkg) \
 		--bindings-package $(pkg) \
@@ -56,7 +56,7 @@ bindgen-generate-local:
 		--forge-artifacts $(contracts-dir)/forge-artifacts
 
 bindgen-remote:
-	go run ./bindgen/ \
+	go run ./cmd/ \
 		generate \
 		--metadata-out ./$(pkg) \
 		--bindings-package $(pkg) \
@@ -80,6 +80,3 @@ clean:
 
 test:
 	go test ./...
-
-test-bindgen-e2e:
-	RUN_E2E=true go test -count=1 ./bindgen/...

op-bindings/bindgen/generator_local.go

-package main
+package bindgen
 
 import (
 	"encoding/json"
@@ -15,10 +15,10 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/foundry"
 )
 
-type bindGenGeneratorLocal struct {
-	bindGenGeneratorBase
-	sourceMapsList     string
-	forgeArtifactsPath string
+type BindGenGeneratorLocal struct {
+	BindGenGeneratorBase
+	SourceMapsList     string
+	ForgeArtifactsPath string
 }
 
 type localContractMetadata struct {
@@ -30,33 +30,33 @@ type localContractMetadata struct {
 	HasImmutableReferences bool
 }
 
-func (generator *bindGenGeneratorLocal) generateBindings() error {
-	contracts, err := readContractList(generator.logger, generator.contractsListPath)
+func (generator *BindGenGeneratorLocal) GenerateBindings() error {
+	contracts, err := readContractList(generator.Logger, generator.ContractsListPath)
 	if err != nil {
-		return fmt.Errorf("error reading contract list %s: %w", generator.contractsListPath, err)
+		return fmt.Errorf("error reading contract list %s: %w", generator.ContractsListPath, err)
 	}
 	if len(contracts.Local) == 0 {
-		return fmt.Errorf("no contracts parsed from given contract list: %s", generator.contractsListPath)
+		return fmt.Errorf("no contracts parsed from given contract list: %s", generator.ContractsListPath)
 	}
 
 	return generator.processContracts(contracts.Local)
 }
 
-func (generator *bindGenGeneratorLocal) processContracts(contracts []string) error {
-	tempArtifactsDir, err := mkTempArtifactsDir(generator.logger)
+func (generator *BindGenGeneratorLocal) processContracts(contracts []string) error {
+	tempArtifactsDir, err := mkTempArtifactsDir(generator.Logger)
 	if err != nil {
 		return err
 	}
 	defer func() {
 		err := os.RemoveAll(tempArtifactsDir)
 		if err != nil {
-			generator.logger.Error("Error removing temporary artifact directory", "path", tempArtifactsDir, "err", err.Error())
+			generator.Logger.Error("Error removing temporary artifact directory", "path", tempArtifactsDir, "err", err.Error())
 		} else {
-			generator.logger.Debug("Successfully removed temporary artifact directory")
+			generator.Logger.Debug("Successfully removed temporary artifact directory")
 		}
 	}()
 
-	sourceMapsList := strings.Split(generator.sourceMapsList, ",")
+	sourceMapsList := strings.Split(generator.SourceMapsList, ",")
 	sourceMapsSet := make(map[string]struct{})
 	for _, k := range sourceMapsList {
 		sourceMapsSet[k] = struct{}{}
@@ -70,19 +70,19 @@ func (generator *bindGenGeneratorLocal) processContracts(contracts []string) err
 	contractMetadataFileTemplate := template.Must(template.New("localContractMetadata").Parse(localContractMetadataTemplate))
 
 	for _, contractName := range contracts {
-		generator.logger.Info("Generating bindings and metadata for local contract", "contract", contractName)
+		generator.Logger.Info("Generating bindings and metadata for local contract", "contract", contractName)
 
 		forgeArtifact, err := generator.readForgeArtifact(contractName, contractArtifactPaths)
 		if err != nil {
 			return err
 		}
 
-		abiFilePath, bytecodeFilePath, err := writeContractArtifacts(generator.logger, tempArtifactsDir, contractName, forgeArtifact.Abi, []byte(forgeArtifact.Bytecode.Object.String()))
+		abiFilePath, bytecodeFilePath, err := writeContractArtifacts(generator.Logger, tempArtifactsDir, contractName, forgeArtifact.Abi, []byte(forgeArtifact.Bytecode.Object.String()))
 		if err != nil {
 			return err
 		}
 
-		err = genContractBindings(generator.logger, generator.monorepoBasePath, abiFilePath, bytecodeFilePath, generator.bindingsPackageName, contractName)
+		err = genContractBindings(generator.Logger, generator.MonorepoBasePath, abiFilePath, bytecodeFilePath, generator.BindingsPackageName, contractName)
 		if err != nil {
 			return err
 		}
@@ -104,7 +104,7 @@ func (generator *bindGenGeneratorLocal) processContracts(contracts []string) err
 			Name:                   contractName,
 			StorageLayout:          canonicalStorageStr,
 			DeployedBin:            forgeArtifact.DeployedBytecode.Object.String(),
-			Package:                generator.bindingsPackageName,
+			Package:                generator.BindingsPackageName,
 			DeployedSourceMap:      deployedSourceMap,
 			HasImmutableReferences: hasImmutables,
 		}
@@ -117,14 +117,14 @@ func (generator *bindGenGeneratorLocal) processContracts(contracts []string) err
 	return nil
 }
 
-func (generator *bindGenGeneratorLocal) getContractArtifactPaths() (map[string]string, error) {
+func (generator *BindGenGeneratorLocal) getContractArtifactPaths() (map[string]string, error) {
 	// If some contracts have the same name then the path to their
 	// artifact depends on their full import path. Scan over all artifacts
 	// and hold a mapping from the contract name to the contract path.
 	// Walk walks the directory deterministically, so the earliest instance
 	// of the contract with the same name will be used
 	artifactPaths := make(map[string]string)
-	if err := filepath.Walk(generator.forgeArtifactsPath,
+	if err := filepath.Walk(generator.ForgeArtifactsPath,
 		func(path string, info os.FileInfo, err error) error {
 			if err != nil {
 				return err
@@ -141,7 +141,7 @@ func (generator *bindGenGeneratorLocal) getContractArtifactPaths() (map[string]s
 				if !ok {
 					artifactPaths[sanitized] = path
 				} else {
-					generator.logger.Warn("Multiple versions of forge artifacts exist, using lesser version", "contract", sanitized)
+					generator.Logger.Warn("Multiple versions of forge artifacts exist, using lesser version", "contract", sanitized)
 				}
 			}
 			return nil
@@ -152,13 +152,13 @@ func (generator *bindGenGeneratorLocal) getContractArtifactPaths() (map[string]s
 	return artifactPaths, nil
 }
 
-func (generator *bindGenGeneratorLocal) readForgeArtifact(contractName string, contractArtifactPaths map[string]string) (foundry.Artifact, error) {
+func (generator *BindGenGeneratorLocal) readForgeArtifact(contractName string, contractArtifactPaths map[string]string) (foundry.Artifact, error) {
 	var forgeArtifact foundry.Artifact
 
-	contractArtifactPath := path.Join(generator.forgeArtifactsPath, contractName+".sol", contractName+".json")
+	contractArtifactPath := path.Join(generator.ForgeArtifactsPath, contractName+".sol", contractName+".json")
 	forgeArtifactRaw, err := os.ReadFile(contractArtifactPath)
 	if errors.Is(err, os.ErrNotExist) {
-		generator.logger.Debug("Cannot find forge-artifact at standard path, trying provided path", "contract", contractName, "standardPath", contractArtifactPath, "providedPath", contractArtifactPaths[contractName])
+		generator.Logger.Debug("Cannot find forge-artifact at standard path, trying provided path", "contract", contractName, "standardPath", contractArtifactPath, "providedPath", contractArtifactPaths[contractName])
 		contractArtifactPath = contractArtifactPaths[contractName]
 		forgeArtifactRaw, err = os.ReadFile(contractArtifactPath)
 		if errors.Is(err, os.ErrNotExist) {
@@ -166,7 +166,7 @@ func (generator *bindGenGeneratorLocal) readForgeArtifact(contractName string, c
 		}
 	}
 
-	generator.logger.Debug("Using forge-artifact", "path", contractArtifactPath)
+	generator.Logger.Debug("Using forge-artifact", "path", contractArtifactPath)
 	if err := json.Unmarshal(forgeArtifactRaw, &forgeArtifact); err != nil {
 		return forgeArtifact, fmt.Errorf("failed to parse forge artifact of %q: %w", contractName, err)
 	}
@@ -174,9 +174,9 @@ func (generator *bindGenGeneratorLocal) readForgeArtifact(contractName string, c
 	return forgeArtifact, nil
 }
 
-func (generator *bindGenGeneratorLocal) canonicalizeStorageLayout(forgeArtifact foundry.Artifact, sourceMapsSet map[string]struct{}, contractName string) (string, string, error) {
+func (generator *BindGenGeneratorLocal) canonicalizeStorageLayout(forgeArtifact foundry.Artifact, sourceMapsSet map[string]struct{}, contractName string) (string, string, error) {
 	artifactStorageStruct := forgeArtifact.StorageLayout
-	canonicalStorageStruct := ast.CanonicalizeASTIDs(&artifactStorageStruct, generator.monorepoBasePath)
+	canonicalStorageStruct := ast.CanonicalizeASTIDs(&artifactStorageStruct, generator.MonorepoBasePath)
 	canonicalStorageJson, err := json.Marshal(canonicalStorageStruct)
 	if err != nil {
 		return "", "", fmt.Errorf("error marshaling canonical storage: %w", err)
@@ -191,8 +191,8 @@ func (generator *bindGenGeneratorLocal) canonicalizeStorageLayout(forgeArtifact
 	return deployedSourceMap, canonicalStorageStr, nil
 }
 
-func (generator *bindGenGeneratorLocal) writeContractMetadata(contractMetaData localContractMetadata, contractName string, fileTemplate *template.Template) error {
-	metadataFilePath := filepath.Join(generator.metadataOut, strings.ToLower(contractName)+"_more.go")
+func (generator *BindGenGeneratorLocal) writeContractMetadata(contractMetaData localContractMetadata, contractName string, fileTemplate *template.Template) error {
+	metadataFilePath := filepath.Join(generator.MetadataOut, strings.ToLower(contractName)+"_more.go")
 	metadataFile, err := os.OpenFile(
 		metadataFilePath,
 		os.O_RDWR|os.O_CREATE|os.O_TRUNC,
@@ -207,7 +207,7 @@ func (generator *bindGenGeneratorLocal) writeContractMetadata(contractMetaData l
 		return fmt.Errorf("error writing %s's contract metadata at %s: %w", contractName, metadataFilePath, err)
 	}
 
-	generator.logger.Debug("Successfully wrote contract metadata", "contract", contractName, "path", metadataFilePath)
+	generator.Logger.Debug("Successfully wrote contract metadata", "contract", contractName, "path", metadataFilePath)
 	return nil
 }
 

op-bindings/bindgen/generator_remote.go

-package main
+package bindgen
 
 import (
 	"context"
@@ -10,15 +10,15 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
-type bindGenGeneratorRemote struct {
-	bindGenGeneratorBase
-	contractDataClients struct {
-		eth contractDataClient
-		op  contractDataClient
+type BindGenGeneratorRemote struct {
+	BindGenGeneratorBase
+	ContractDataClients struct {
+		Eth contractDataClient
+		Op  contractDataClient
 	}
-	rpcClients struct {
-		eth *ethclient.Client
-		op  *ethclient.Client
+	RpcClients struct {
+		Eth *ethclient.Client
+		Op  *ethclient.Client
 	}
 	tempArtifactsDir string
 }
@@ -30,67 +30,67 @@ type contractDataClient interface {
 	FetchDeploymentTx(ctx context.Context, txHash string) (etherscan.Transaction, error)
 }
 
-type deployments struct {
+type Deployments struct {
 	Eth common.Address `json:"eth"`
 	Op  common.Address `json:"op"`
 }
 
-type remoteContract struct {
+type RemoteContract struct {
 	Name           string         `json:"name"`
 	Verified       bool           `json:"verified"`
-	Deployments    deployments    `json:"deployments"`
+	Deployments    Deployments    `json:"deployments"`
 	DeploymentSalt string         `json:"deploymentSalt"`
 	Deployer       common.Address `json:"deployer"`
 	ABI            string         `json:"abi"`
 	InitBytecode   string         `json:"initBytecode"`
 }
 
-type remoteContractMetadata struct {
-	remoteContract
+type RemoteContractMetadata struct {
+	RemoteContract
 	Package     string
 	InitBin     string
 	DeployedBin string
 }
 
-func (generator *bindGenGeneratorRemote) generateBindings() error {
-	contracts, err := readContractList(generator.logger, generator.contractsListPath)
+func (generator *BindGenGeneratorRemote) GenerateBindings() error {
+	contracts, err := readContractList(generator.Logger, generator.ContractsListPath)
 	if err != nil {
-		return fmt.Errorf("error reading contract list %s: %w", generator.contractsListPath, err)
+		return fmt.Errorf("error reading contract list %s: %w", generator.ContractsListPath, err)
 	}
 	if len(contracts.Remote) == 0 {
-		return fmt.Errorf("no contracts parsed from given contract list: %s", generator.contractsListPath)
+		return fmt.Errorf("no contracts parsed from given contract list: %s", generator.ContractsListPath)
 	}
 
 	return generator.processContracts(contracts.Remote)
 }
 
-func (generator *bindGenGeneratorRemote) processContracts(contracts []remoteContract) error {
+func (generator *BindGenGeneratorRemote) processContracts(contracts []RemoteContract) error {
 	var err error
-	generator.tempArtifactsDir, err = mkTempArtifactsDir(generator.logger)
+	generator.tempArtifactsDir, err = mkTempArtifactsDir(generator.Logger)
 	if err != nil {
 		return err
 	}
 	defer func() {
 		err := os.RemoveAll(generator.tempArtifactsDir)
 		if err != nil {
-			generator.logger.Error("Error removing temporary artifact directory", "path", generator.tempArtifactsDir, "err", err.Error())
+			generator.Logger.Error("Error removing temporary artifact directory", "path", generator.tempArtifactsDir, "err", err.Error())
 		} else {
-			generator.logger.Debug("Successfully removed temporary artifact directory")
+			generator.Logger.Debug("Successfully removed temporary artifact directory")
 		}
 	}()
 
 	for _, contract := range contracts {
-		generator.logger.Info("Generating bindings and metadata for remote contract", "contract", contract.Name)
+		generator.Logger.Info("Generating bindings and metadata for remote contract", "contract", contract.Name)
 
-		contractMetadata := remoteContractMetadata{
-			remoteContract: remoteContract{
+		contractMetadata := RemoteContractMetadata{
+			RemoteContract: RemoteContract{
 				Name:           contract.Name,
 				Deployments:    contract.Deployments,
 				DeploymentSalt: contract.DeploymentSalt,
 				ABI:            contract.ABI,
 				Verified:       contract.Verified,
 			},
-			Package: generator.bindingsPackageName,
+			Package: generator.BindingsPackageName,
 		}
 
 		var err error

op-bindings/bindgen/remote_handlers_test.go

-package main
+package bindgen
 
 import (
-	"fmt"
-	"os"
-	"reflect"
-	"strings"
 	"testing"
 
-	"github.com/ethereum-optimism/optimism/op-bindings/etherscan"
-	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/stretchr/testify/require"
 )
 
-var generator bindGenGeneratorRemote = bindGenGeneratorRemote{}
-
-func configureGenerator(t *testing.T) error {
-	if os.Getenv("RUN_E2E") == "" {
-		t.Log("Not running test, RUN_E2E env not set")
-		t.Skip()
-	}
-
-	generator.contractDataClients.eth = etherscan.NewEthereumClient(os.Getenv("ETHERSCAN_APIKEY_ETH"))
-	generator.contractDataClients.op = etherscan.NewOptimismClient(os.Getenv("ETHERSCAN_APIKEY_OP"))
-
-	var err error
-	if generator.rpcClients.eth, err = ethclient.Dial(os.Getenv("RPC_URL_ETH")); err != nil {
-		return fmt.Errorf("error initializing Ethereum client: %w", err)
-	}
-	if generator.rpcClients.op, err = ethclient.Dial(os.Getenv("RPC_URL_OP")); err != nil {
-		return fmt.Errorf("error initializing Optimism client: %w", err)
-	}
-
-	return nil
-}
-
-func TestFetchContractData(t *testing.T) {
-	if err := configureGenerator(t); err != nil {
-		t.Error(err)
-	}
-
-	for _, tt := range fetchContractDataTests {
-		t.Run(tt.name, func(t *testing.T) {
-			contractData, err := generator.fetchContractData(tt.contractVerified, tt.chain, tt.deploymentAddress)
-			if err != nil {
-				t.Error(err)
-			}
-			if !reflect.DeepEqual(contractData, tt.expectedContractData) {
-				t.Errorf("Retrieved contract data doesn't match expected. Expected: %s Retrieved: %s", tt.expectedContractData, contractData)
-			}
-		})
-	}
-}
-
-func TestFetchContractDataFailures(t *testing.T) {
-	if err := configureGenerator(t); err != nil {
-		t.Error(err)
-	}
-
-	for _, tt := range fetchContractDataTestsFailures {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := generator.fetchContractData(tt.contractVerified, tt.chain, tt.deploymentAddress)
-			if err == nil {
-				t.Errorf("Expected error: %s but didn't receive it", tt.expectedError)
-				return
-			}
-
-			if !strings.Contains(err.Error(), tt.expectedError) {
-				t.Errorf("Expected error: %s Received: %s", tt.expectedError, err)
-				return
-			}
-		})
-	}
-}
+var generator BindGenGeneratorRemote = BindGenGeneratorRemote{}
 
 func TestRemoveDeploymentSalt(t *testing.T) {
 	for _, tt := range removeDeploymentSaltTests {
@@ -90,111 +25,3 @@ func TestRemoveDeploymentSaltFailures(t *testing.T) {
 		})
 	}
 }
-
-func TestCompareInitBytecodeWithOp(t *testing.T) {
-	if err := configureGenerator(t); err != nil {
-		t.Error(err)
-	}
-
-	for _, tt := range compareInitBytecodeWithOpTests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := generator.compareInitBytecodeWithOp(&tt.contractMetadataEth, tt.initCodeShouldMatch)
-			if err != nil {
-				t.Error(err)
-			}
-		})
-	}
-}
-
-func TestCompareInitBytecodeWithOpFailures(t *testing.T) {
-	if err := configureGenerator(t); err != nil {
-		t.Error(err)
-	}
-
-	for _, tt := range compareInitBytecodeWithOpTestsFailures {
-		t.Run(tt.name, func(t *testing.T) {
-			err := generator.compareInitBytecodeWithOp(&tt.contractMetadataEth, tt.initCodeShouldMatch)
-			if err == nil {
-				t.Errorf("Expected error: %s but didn't receive it", tt.expectedError)
-				return
-			}
-
-			if !strings.Contains(err.Error(), tt.expectedError) {
-				t.Errorf("Expected error: %s Received: %s", tt.expectedError, err)
-				return
-			}
-		})
-	}
-}
-
-func TestCompareDeployedBytecodeWithOp(t *testing.T) {
-	if err := configureGenerator(t); err != nil {
-		t.Error(err)
-	}
-
-	for _, tt := range compareDeployedBytecodeWithOpTests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := generator.compareDeployedBytecodeWithOp(&tt.contractMetadataEth, tt.deployedCodeShouldMatch)
-			if err != nil {
-				t.Error(err)
-			}
-		})
-	}
-}
-
-func TestCompareDeployedBytecodeWithOpFailures(t *testing.T) {
-	if err := configureGenerator(t); err != nil {
-		t.Error(err)
-	}
-
-	for _, tt := range compareDeployedBytecodeWithOpTestsFailures {
-		t.Run(tt.name, func(t *testing.T) {
-			err := generator.compareDeployedBytecodeWithOp(&tt.contractMetadataEth, tt.deployedCodeShouldMatch)
-			if err == nil {
-				t.Errorf("Expected error: %s but didn't receive it", tt.expectedError)
-				return
-			}
-
-			if !strings.Contains(err.Error(), tt.expectedError) {
-				t.Errorf("Expected error: %s Received: %s", tt.expectedError, err)
-				return
-			}
-		})
-	}
-}
-
-func TestCompareDeployedBytecodeWithRpc(t *testing.T) {
-	if err := configureGenerator(t); err != nil {
-		t.Error(err)
-	}
-
-	for _, tt := range compareDeployedBytecodeWithRpcTests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := generator.compareDeployedBytecodeWithRpc(&tt.contractMetadataEth, tt.chain)
-			if err != nil {
-				t.Error(err)
-			}
-		})
-	}
-}
-
-func TestCompareDeployedBytecodeWithRpcFailures(t *testing.T) {
-	if err := configureGenerator(t); err != nil {
-		t.Error(err)
-	}
-
-	for _, tt := range compareDeployedBytecodeWithRpcTestsFailures {
-		t.Run(tt.name, func(t *testing.T) {
-			err := generator.compareDeployedBytecodeWithRpc(&tt.contractMetadataEth, tt.chain)
-			if err == nil {
-				t.Errorf("Expected error: %s but didn't receive it", tt.expectedError)
-				return
-			}
-
-			if !strings.Contains(err.Error(), tt.expectedError) {
-				t.Errorf("Expected error: %s Received: %s", tt.expectedError, err)
-				return
-			}
-		})
-	}
-}

op-bindings/bindgen/utils.go

-package main
+package bindgen
 
 import (
 	"bufio"
@@ -13,9 +13,17 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
+type BindGenGeneratorBase struct {
+	MetadataOut         string
+	BindingsPackageName string
+	MonorepoBasePath    string
+	ContractsListPath   string
+	Logger              log.Logger
+}
+
 type contractsList struct {
 	Local  []string         `json:"local"`
-	Remote []remoteContract `json:"remote"`
+	Remote []RemoteContract `json:"remote"`
 }
 
 // readContractList reads a JSON file from the given `filePath` and unmarshals

op-bindings/bindgen/main.go → op-bindings/cmd/main.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/ethereum-optimism/optimism/op-bindings/bindgen"
 	"github.com/ethereum-optimism/optimism/op-bindings/etherscan"
 	op_service "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
@@ -12,14 +13,6 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
-type bindGenGeneratorBase struct {
-	metadataOut         string
-	bindingsPackageName string
-	monorepoBasePath    string
-	contractsListPath   string
-	logger              log.Logger
-}
-
 const (
 	// Base Flags
 	MetadataOutFlagName         = "metadata-out"
@@ -92,7 +85,7 @@ func generateBindings(c *cli.Context) error {
 		if err != nil {
 			return err
 		}
-		if err := localBindingsGenerator.generateBindings(); err != nil {
+		if err := localBindingsGenerator.GenerateBindings(); err != nil {
 			return fmt.Errorf("error generating local bindings: %w", err)
 		}
 
@@ -100,7 +93,7 @@ func generateBindings(c *cli.Context) error {
 		if err != nil {
 			return err
 		}
-		if err := remoteBindingsGenerator.generateBindings(); err != nil {
+		if err := remoteBindingsGenerator.GenerateBindings(); err != nil {
 			return fmt.Errorf("error generating remote bindings: %w", err)
 		}
 
@@ -110,7 +103,7 @@ func generateBindings(c *cli.Context) error {
 		if err != nil {
 			return err
 		}
-		if err := localBindingsGenerator.generateBindings(); err != nil {
+		if err := localBindingsGenerator.GenerateBindings(); err != nil {
 			return fmt.Errorf("error generating local bindings: %w", err)
 		}
 		return nil
@@ -119,7 +112,7 @@ func generateBindings(c *cli.Context) error {
 		if err != nil {
 			return err
 		}
-		if err := remoteBindingsGenerator.generateBindings(); err != nil {
+		if err := remoteBindingsGenerator.GenerateBindings(); err != nil {
 			return fmt.Errorf("error generating remote bindings: %w", err)
 		}
 		return nil
@@ -128,55 +121,55 @@ func generateBindings(c *cli.Context) error {
 	}
 }
 
-func parseConfigBase(logger log.Logger, c *cli.Context) (bindGenGeneratorBase, error) {
+func parseConfigBase(logger log.Logger, c *cli.Context) (bindgen.BindGenGeneratorBase, error) {
 	cwd, err := os.Getwd()
 	if err != nil {
-		return bindGenGeneratorBase{}, err
+		return bindgen.BindGenGeneratorBase{}, err
 	}
 
 	monoRepoPath, err := op_service.FindMonorepoRoot(cwd)
 	if err != nil {
-		return bindGenGeneratorBase{}, err
+		return bindgen.BindGenGeneratorBase{}, err
 	}
 
-	return bindGenGeneratorBase{
-		metadataOut:         c.String(MetadataOutFlagName),
-		bindingsPackageName: c.String(BindingsPackageNameFlagName),
-		monorepoBasePath:    monoRepoPath,
-		contractsListPath:   c.String(ContractsListFlagName),
-		logger:              logger,
+	return bindgen.BindGenGeneratorBase{
+		MetadataOut:         c.String(MetadataOutFlagName),
+		BindingsPackageName: c.String(BindingsPackageNameFlagName),
+		MonorepoBasePath:    monoRepoPath,
+		ContractsListPath:   c.String(ContractsListFlagName),
+		Logger:              logger,
 	}, nil
 }
 
-func parseConfigLocal(logger log.Logger, c *cli.Context) (bindGenGeneratorLocal, error) {
+func parseConfigLocal(logger log.Logger, c *cli.Context) (bindgen.BindGenGeneratorLocal, error) {
 	baseConfig, err := parseConfigBase(logger, c)
 	if err != nil {
-		return bindGenGeneratorLocal{}, err
+		return bindgen.BindGenGeneratorLocal{}, err
 	}
-	return bindGenGeneratorLocal{
-		bindGenGeneratorBase: baseConfig,
-		sourceMapsList:       c.String(SourceMapsListFlagName),
-		forgeArtifactsPath:   c.String(ForgeArtifactsFlagName),
+	return bindgen.BindGenGeneratorLocal{
+		BindGenGeneratorBase: baseConfig,
+		SourceMapsList:       c.String(SourceMapsListFlagName),
+		ForgeArtifactsPath:   c.String(ForgeArtifactsFlagName),
 	}, nil
 }
 
-func parseConfigRemote(logger log.Logger, c *cli.Context) (bindGenGeneratorRemote, error) {
+func parseConfigRemote(logger log.Logger, c *cli.Context) (bindgen.BindGenGeneratorRemote, error) {
 	baseConfig, err := parseConfigBase(logger, c)
 	if err != nil {
-		return bindGenGeneratorRemote{}, err
+		return bindgen.BindGenGeneratorRemote{}, err
 	}
-	generator := bindGenGeneratorRemote{
-		bindGenGeneratorBase: baseConfig,
+	generator := bindgen.BindGenGeneratorRemote{
+		BindGenGeneratorBase: baseConfig,
 	}
 
-	generator.contractDataClients.eth = etherscan.NewEthereumClient(c.String(EtherscanApiKeyEthFlagName))
-	generator.contractDataClients.op = etherscan.NewOptimismClient(c.String(EtherscanApiKeyOpFlagName))
+	generator.ContractDataClients.Eth = etherscan.NewEthereumClient(c.String(EtherscanApiKeyEthFlagName))
+	generator.ContractDataClients.Op = etherscan.NewOptimismClient(c.String(EtherscanApiKeyOpFlagName))
 
-	if generator.rpcClients.eth, err = ethclient.Dial(c.String(RpcUrlEthFlagName)); err != nil {
-		return bindGenGeneratorRemote{}, fmt.Errorf("error initializing Ethereum client: %w", err)
+	if generator.RpcClients.Eth, err = ethclient.Dial(c.String(RpcUrlEthFlagName)); err != nil {
+		return bindgen.BindGenGeneratorRemote{}, fmt.Errorf("error initializing Ethereum client: %w", err)
 	}
-	if generator.rpcClients.op, err = ethclient.Dial(c.String(RpcUrlOpFlagName)); err != nil {
-		return bindGenGeneratorRemote{}, fmt.Errorf("error initializing Optimism client: %w", err)
+	if generator.RpcClients.Op, err = ethclient.Dial(c.String(RpcUrlOpFlagName)); err != nil {
+		return bindgen.BindGenGeneratorRemote{}, fmt.Errorf("error initializing Optimism client: %w", err)
 	}
 	return generator, nil
 }