fix: all linter issues

libevm/ethtest/rand.go

@@ -17,7 +17,7 @@ func NewPseudoRand(seed uint64) *PseudoRand {
 
 // Address returns a pseudorandom address.
 func (r *PseudoRand) Address() (a common.Address) {
-	r.Read(a[:])
+	r.Read(a[:]) //nolint:gosec,errcheck // Guaranteed nil error
 	return a
 }
 
@@ -29,13 +29,13 @@ func (r *PseudoRand) AddressPtr() *common.Address {
 
 // Hash returns a pseudorandom hash.
 func (r *PseudoRand) Hash() (h common.Hash) {
-	r.Read(h[:])
+	r.Read(h[:]) //nolint:gosec,errcheck // Guaranteed nil error
 	return h
 }
 
 // Bytes returns `n` pseudorandom bytes.
 func (r *PseudoRand) Bytes(n uint) []byte {
 	b := make([]byte, n)
-	r.Read(b)
+	r.Read(b) //nolint:gosec,errcheck // Guaranteed nil error
 	return b
 }

libevm/hookstest/stub.go

@@ -15,6 +15,7 @@ import (
 // for the lifetime of the current test, clearing them via tb's
 // [testing.TB.Cleanup].
 func Register[C params.ChainConfigHooks, R params.RulesHooks](tb testing.TB, extras params.Extras[C, R]) {
+	tb.Helper()
 	params.TestOnlyClearRegisteredExtras()
 	tb.Cleanup(params.TestOnlyClearRegisteredExtras)
 	params.RegisterExtras(extras)
@@ -32,13 +33,17 @@ type Stub struct {
 // Register is a convenience wrapper for registering s as both the
 // [params.ChainConfigHooks] and [params.RulesHooks] via [Register].
 func (s *Stub) Register(tb testing.TB) {
+	tb.Helper()
 	Register(tb, params.Extras[*Stub, *Stub]{
 		NewRules: func(_ *params.ChainConfig, _ *params.Rules, _ *Stub, blockNum *big.Int, isMerge bool, timestamp uint64) *Stub {
 			return s
 		},
 	})
 }
 
+// PrecompileOverride uses the s.PrecompileOverrides map, if non-empty, as the
+// canonical source of all overrides. If the map is empty then no precompiles
+// are overridden.
 func (s Stub) PrecompileOverride(a common.Address) (libevm.PrecompiledContract, bool) {
 	if len(s.PrecompileOverrides) == 0 {
 		return nil, false
@@ -47,13 +52,17 @@ func (s Stub) PrecompileOverride(a common.Address) (libevm.PrecompiledContract,
 	return p, ok
 }
 
+// CanExecuteTransaction proxies arguments to the s.CanExecuteTransactionFn
+// function if non-nil, otherwise it acts as a noop.
 func (s Stub) CanExecuteTransaction(from common.Address, to *common.Address, sr libevm.StateReader) error {
 	if f := s.CanExecuteTransactionFn; f != nil {
 		return f(from, to, sr)
 	}
 	return nil
 }
 
+// CanCreateContract proxies arguments to the s.CanCreateContractFn function if
+// non-nil, otherwise it acts as a noop.
 func (s Stub) CanCreateContract(cc *libevm.AddressContext, sr libevm.StateReader) error {
 	if f := s.CanCreateContractFn; f != nil {
 		return f(cc, sr)

libevm/pseudo/constructor_test.go

@@ -14,6 +14,7 @@ func TestConstructor(t *testing.T) {
 	testConstructor[struct{ x string }](t)
 }
 
+//nolint:thelper // This is the test itself so we want local line numbers reported.
 func testConstructor[T any](t *testing.T) {
 	var zero T
 	t.Run(fmt.Sprintf("%T", zero), func(t *testing.T) {

libevm/pseudo/type.go

@@ -106,10 +106,10 @@ func MustNewValue[T any](t *Type) *Value[T] {
 }
 
 // Get returns the value.
-func (a *Value[T]) Get() T { return a.t.val.get().(T) }
+func (v *Value[T]) Get() T { return v.t.val.get().(T) } //nolint:forcetypeassert // invariant
 
 // Set sets the value.
-func (a *Value[T]) Set(v T) { a.t.val.mustSet(v) }
+func (v *Value[T]) Set(val T) { v.t.val.mustSet(val) }
 
 // MarshalJSON implements the [json.Marshaler] interface.
 func (t *Type) MarshalJSON() ([]byte, error) { return t.val.MarshalJSON() }

libevm/pseudo/type_test.go

@@ -24,6 +24,7 @@ func TestType(t *testing.T) {
 	testType(t, "nil pointer", Zero[*float64], (*float64)(nil), new(float64), 0)
 }
 
+//nolint:thelper // This is the test itself so we want local line numbers reported.
 func testType[T any](t *testing.T, name string, ctor func() *Pseudo[T], init T, setTo T, invalid any) {
 	t.Run(name, func(t *testing.T) {
 		typ, val := ctor().TypeAndValue()
@@ -67,7 +68,7 @@ func testType[T any](t *testing.T, name string, ctor func() *Pseudo[T], init T,
 	})
 }
 
-//nolint:ineffassign // Although `typ` is overwritten it's to demonstrate different approaches.
+//nolint:ineffassign,testableexamples // Although `typ` is overwritten it's to demonstrate different approaches
 func ExamplePseudo_TypeAndValue() {
 	typ, val := From("hello").TypeAndValue()
 

params/config.libevm.go

@@ -140,7 +140,7 @@ func notStructMessage[T any]() string {
 	return fmt.Sprintf("%T is not a struct nor a pointer to a struct", x)
 }
 
-// An ExtraPayloadGettter provides strongly typed access to the extra payloads
+// An ExtraPayloadGetter provides strongly typed access to the extra payloads
 // carried by [ChainConfig] and [Rules] structs. The only valid way to construct
 // a getter is by a call to [RegisterExtras].
 type ExtraPayloadGetter[C ChainConfigHooks, R RulesHooks] struct {

params/config.libevm_test.go

@@ -102,18 +102,18 @@ func TestRegisterExtras(t *testing.T) {
 			tt.register()
 			defer TestOnlyClearRegisteredExtras()
 
-			in := &ChainConfig{
+			input := &ChainConfig{
 				ChainID: big.NewInt(142857),
 				extra:   tt.ccExtra,
 			}
 
-			buf, err := json.Marshal(in)
+			buf, err := json.Marshal(input)
 			require.NoError(t, err)
 
 			got := new(ChainConfig)
 			require.NoError(t, json.Unmarshal(buf, got))
 			assert.Equal(t, tt.ccExtra.Interface(), got.extraPayload().Interface())
-			assert.Equal(t, in, got)
+			assert.Equal(t, input, got)
 
 			gotRules := got.Rules(nil, false, 0)
 			assert.Equal(t, tt.wantRulesExtra, gotRules.extraPayload().Interface())

params/example.libevm_test.go

@@ -107,7 +107,7 @@ func (r RulesExtra) PrecompileOverride(addr common.Address) (_ libevm.Precompile
 // implementation detail.
 func (r RulesExtra) CanCreateContract(*libevm.AddressContext, libevm.StateReader) error {
 	if time.Unix(int64(r.timestamp), 0).UTC().Day() != int(time.Tuesday) {
-		return errors.New("uh oh!")
+		return errors.New("uh oh")
 	}
 	return nil
 }