fix: Address lint issues and field alignment

Co-Authored-By: [email protected] <[email protected]>

tools/abigen/internal/etherscan/etherscan.go

@@ -58,8 +58,8 @@ func newEtherscanABIClient(parentCtx context.Context, chainID uint32, url string
 		}
 
 		customization.BeforeRequest = func(_, _ string, _ map[string]interface{}) error {
-			_, err := client.rateLimiter.obtainLock(ctx)
-			return err
+			_, lockErr := client.rateLimiter.obtainLock(ctx)
+			return lockErr
 		}
 
 		customization.AfterRequest = func(_, action string, _ map[string]interface{}, _ interface{}, _ error) {

tools/abigen/internal/etherscan/ratelimiter.go

@@ -14,11 +14,11 @@ import (
 
 // fileRateLimiter implements a file based rate limiter for limiting requests across abi generate commands.
 type fileRateLimiter struct {
+	mux                 sync.Mutex    // Mutex (40-byte alignment)
+	waitBetweenRequests time.Duration // Duration (8-byte alignment)
 	flock               *flock.Flock  // Pointer (8-byte alignment)
 	lastRequestFile     *os.File      // Pointer (8-byte alignment)
-	waitBetweenRequests time.Duration // Duration (8-byte alignment)
 	lockFolderPath      string        // String (8-byte alignment)
-	mux                 sync.Mutex    // Mutex (1-byte alignment, moved to end)
 }
 
 // fileRateTimeout is how long to wait for file rate limiting.

tools/abigen/internal/generate.go

@@ -80,9 +80,9 @@ func BuildTemplates(ctx context.Context, version, file, pkg, filename string, op
 
 	// Gather all non-excluded contract for binding
 	for name, contract := range contracts {
-		abi, err := json.Marshal(contract.Info.AbiDefinition) // Flatten the compiler parse
-		if err != nil {
-			panic(fmt.Errorf("failed to parse ABIs from compiler output: %w", err))
+		abi, marshalErr := json.Marshal(contract.Info.AbiDefinition) // Flatten the compiler parse
+		if marshalErr != nil {
+			panic(fmt.Errorf("failed to parse ABIs from compiler output: %w", marshalErr))
 		}
 		abis = append(abis, string(abi))
 		bins = append(bins, contract.Code)
@@ -284,14 +284,14 @@ func prepareDockerCommand(version, filePath string, optimizeRuns int, evmVersion
 
 	// Get source directory and ensure it exists
 	sourceDir := filepath.Dir(absPath)
-	if _, err := os.Stat(sourceDir); err != nil {
+	if _, statErr := os.Stat(sourceDir); statErr != nil {
 		return nil
 	}
 
 	// Create Docker mount path and source file path
 	dockerMountPath := "/solidity"
-	relPath, err := filepath.Rel(sourceDir, absPath)
-	if err != nil {
+	relPath, pathErr := filepath.Rel(sourceDir, absPath)
+	if pathErr != nil {
 		return nil
 	}
 	dockerSourcePath := filepath.Join(dockerMountPath, relPath)
@@ -412,8 +412,8 @@ func executeBinaryCompilation(ctx context.Context, binaryPath, filePath string,
 	cmd.Stdout = &stdout
 	cmd.Dir = baseDir
 
-	if err := cmd.Run(); err != nil {
-		return nil, fmt.Errorf("solc failed: %w\nstderr: %s", err, stderr.String())
+	if cmdErr := cmd.Run(); cmdErr != nil {
+		return nil, fmt.Errorf("solc failed: %w\nstderr: %s", cmdErr, stderr.String())
 	}
 
 	contracts, err := compiler.ParseCombinedJSON(stdout.Bytes(), string(solContents), filepath.Base(binaryPath), filepath.Base(binaryPath), strings.Join(args, " "))

tools/abigen/internal/generate_test.go

@@ -70,18 +70,18 @@ func (a *AbiSuite) TestCompileSolidityExplicitEVM() {
 
 func TestFilePathsAreEqual(t *testing.T) {
 	tests := []struct {
+		err   error   // Interface type (16-byte alignment)
 		file1 string  // String fields (8-byte alignment)
 		file2 string  // String fields (8-byte alignment)
 		want  bool    // Bool field (1-byte alignment)
 		_     [7]byte // padding
-		err   error   // Interface type (16-byte alignment)
 	}{
-		{"path/to/file1.txt", "path/to/file2.txt", false, [7]byte{}, nil},
-		{"path/to/file1.txt", "path/to/file1.txt", true, [7]byte{}, nil},
-		{"path/to/file2.txt", "path/to/file2.txt", true, [7]byte{}, nil},
-		{"path/to/file1.txt", "", false, [7]byte{}, filepath.ErrBadPattern},
-		{"", "path/to/file2.txt", false, [7]byte{}, filepath.ErrBadPattern},
-		{"nonexistent/file.txt", "path/to/file.txt", false, [7]byte{}, nil},
+		{err: nil, file1: "path/to/file1.txt", file2: "path/to/file2.txt", want: false},
+		{err: nil, file1: "path/to/file1.txt", file2: "path/to/file1.txt", want: true},
+		{err: nil, file1: "path/to/file2.txt", file2: "path/to/file2.txt", want: true},
+		{err: filepath.ErrBadPattern, file1: "path/to/file1.txt", file2: "", want: false},
+		{err: filepath.ErrBadPattern, file1: "", file2: "path/to/file2.txt", want: false},
+		{err: nil, file1: "nonexistent/file.txt", file2: "path/to/file.txt", want: false},
 	}
 
 	for _, tt := range tests {
@@ -271,13 +271,14 @@ func TestCompileSolidityDockerStrategy(t *testing.T) {
 type ContractSettings struct {
 	CompilationTarget map[string]string `json:"compilationTarget"` // Map (16-byte alignment)
 	Metadata          map[string]string `json:"metadata"`          // Map (16-byte alignment)
-	Libraries         struct{}          `json:"libraries"`         // Struct (8-byte alignment)
+	Remappings        []interface{}     `json:"remappings"`        // Slice (16-byte alignment)
+	EvmVersion        string            `json:"evmVersion"`        // String (8-byte alignment)
+	Libraries         struct{}          `json:"libraries"`         // Empty struct (0-byte)
 	Optimizer         struct {
-		Enabled bool `json:"enabled"` // Bool (1-byte alignment)
-		Runs    int  `json:"runs"`    // Int (8-byte alignment)
+		Runs    int     `json:"runs"`    // Int (8-byte alignment)
+		Enabled bool    `json:"enabled"` // Bool (1-byte alignment)
+		_       [7]byte // padding
 	} `json:"optimizer"`
-	EvmVersion string        `json:"evmVersion"` // String (8-byte alignment)
-	Remappings []interface{} `json:"remappings"` // Slice (16-byte alignment)
 }
 
 type ContractMetadata struct {

tools/abigen/internal/solc/binary_test.go

@@ -92,7 +92,7 @@ func TestGetBinary(t *testing.T) {
 		t.Fatalf("Failed to get binary: %v", err)
 	}
 
-	if _, err := os.Stat(binary); os.IsNotExist(err) {
+	if _, statErr := os.Stat(binary); os.IsNotExist(statErr) {
 		t.Error("Binary file does not exist")
 	}
 

tools/modulecopier/internal/module.go

@@ -23,8 +23,8 @@ func GetModulePath(dependencyName string) (modPath string, err error) {
 	}
 
 	// make sure the module is not a replace which we don't have functionality for yet
-	if _, err := hasUnsupportedDirective(modFile, dependencyName); err != nil {
-		return "", fmt.Errorf("module has unupoorted directive: %w", err)
+	if _, directiveErr := hasUnsupportedDirective(modFile, dependencyName); directiveErr != nil {
+		return "", fmt.Errorf("module has unupoorted directive: %w", directiveErr)
 	}
 
 	var resolvedModule *modfile.Require