diff --git a/.golangci.yml b/.golangci.yml index 163d2770184d..3b19049b020f 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -71,7 +71,7 @@ linters: # - iotamixing - mirror - misspell - # - modernize + - modernize - nakedret - nilerr # - noctx @@ -268,3 +268,6 @@ linters: linters: - gosec - prealloc + - path: "^graft/" + linters: + - modernize diff --git a/api/admin/client.go b/api/admin/client.go index 1ae4010387dc..afd0a4031c4f 100644 --- a/api/admin/client.go +++ b/api/admin/client.go @@ -117,8 +117,8 @@ func (c *Client) GetLoggerLevel( return res.LoggerLevels, err } -func (c *Client) GetConfig(ctx context.Context, options ...rpc.Option) (interface{}, error) { - var res interface{} +func (c *Client) GetConfig(ctx context.Context, options ...rpc.Option) (any, error) { + var res any err := c.Requester.SendRequest(ctx, "admin.getConfig", struct{}{}, &res, options...) return res, err } diff --git a/api/admin/client_test.go b/api/admin/client_test.go index 2138fe34fcc2..27d69c82d536 100644 --- a/api/admin/client_test.go +++ b/api/admin/client_test.go @@ -35,19 +35,19 @@ var ( ) type mockClient struct { - response interface{} + response any err error } // NewMockClient returns a mock client for testing -func NewMockClient(response interface{}, err error) rpc.EndpointRequester { +func NewMockClient(response any, err error) rpc.EndpointRequester { return &mockClient{ response: response, err: err, } } -func (mc *mockClient) SendRequest(_ context.Context, _ string, _ interface{}, reply interface{}, _ ...rpc.Option) error { +func (mc *mockClient) SendRequest(_ context.Context, _ string, _ any, reply any, _ ...rpc.Option) error { if mc.err != nil { return mc.err } @@ -65,8 +65,8 @@ func (mc *mockClient) SendRequest(_ context.Context, _ string, _ interface{}, re case *LoggerLevelReply: response := mc.response.(*LoggerLevelReply) *p = *response - case *interface{}: - response := mc.response.(*interface{}) + case *any: + response := mc.response.(*any) *p = *response default: panic("illegal type") @@ -323,9 +323,9 @@ func TestGetConfig(t *testing.T) { name string serviceErr error clientErr error - expectedResponse interface{} + expectedResponse any } - var resp interface{} = "response" + var resp any = "response" tests := []test{ { name: "Happy path", diff --git a/api/admin/service.go b/api/admin/service.go index d90633615d12..bd0b561d5cf4 100644 --- a/api/admin/service.go +++ b/api/admin/service.go @@ -47,7 +47,7 @@ type Config struct { Log logging.Logger ProfileDir string LogFactory logging.Factory - NodeConfig interface{} + NodeConfig any DB database.Database ChainManager chains.Manager HTTPServer server.PathAdderWithReadLock @@ -311,7 +311,7 @@ func (a *Admin) GetLoggerLevel(_ *http.Request, args *GetLoggerLevelArgs, reply } // GetConfig returns the config that the node was started with. -func (a *Admin) GetConfig(_ *http.Request, _ *struct{}, reply *interface{}) error { +func (a *Admin) GetConfig(_ *http.Request, _ *struct{}, reply *any) error { a.Log.Debug("API called", zap.String("service", "admin"), zap.String("method", "getConfig"), diff --git a/api/health/checker.go b/api/health/checker.go index 60989d069b41..0219cded8ca1 100644 --- a/api/health/checker.go +++ b/api/health/checker.go @@ -13,11 +13,11 @@ type Checker interface { // error // // It is expected that the results are json marshallable. - HealthCheck(context.Context) (interface{}, error) + HealthCheck(context.Context) (any, error) } -type CheckerFunc func(context.Context) (interface{}, error) +type CheckerFunc func(context.Context) (any, error) -func (f CheckerFunc) HealthCheck(ctx context.Context) (interface{}, error) { +func (f CheckerFunc) HealthCheck(ctx context.Context) (any, error) { return f(ctx) } diff --git a/api/health/client_test.go b/api/health/client_test.go index a0912aa74a3d..899f7d01ab58 100644 --- a/api/health/client_test.go +++ b/api/health/client_test.go @@ -19,7 +19,7 @@ type mockClient struct { onCall func() } -func (mc *mockClient) SendRequest(_ context.Context, _ string, _ interface{}, replyIntf interface{}, _ ...rpc.Option) error { +func (mc *mockClient) SendRequest(_ context.Context, _ string, _ any, replyIntf any, _ ...rpc.Option) error { reply := replyIntf.(*APIReply) *reply = mc.reply mc.onCall() diff --git a/api/health/health_test.go b/api/health/health_test.go index 9be38fc23202..075886a6d983 100644 --- a/api/health/health_test.go +++ b/api/health/health_test.go @@ -50,7 +50,7 @@ func awaitLiveness(t *testing.T, r Reporter, liveness bool) { func TestDuplicatedRegistrations(t *testing.T) { require := require.New(t) - check := CheckerFunc(func(context.Context) (interface{}, error) { + check := CheckerFunc(func(context.Context) (any, error) { return "", nil }) @@ -73,7 +73,7 @@ func TestDuplicatedRegistrations(t *testing.T) { func TestDefaultFailing(t *testing.T) { require := require.New(t) - check := CheckerFunc(func(context.Context) (interface{}, error) { + check := CheckerFunc(func(context.Context) (any, error) { return "", nil }) @@ -114,7 +114,7 @@ func TestDefaultFailing(t *testing.T) { func TestPassingChecks(t *testing.T) { require := require.New(t) - check := CheckerFunc(func(context.Context) (interface{}, error) { + check := CheckerFunc(func(context.Context) (any, error) { return "", nil }) @@ -175,7 +175,7 @@ func TestPassingThenFailingChecks(t *testing.T) { require := require.New(t) var shouldCheckErr utils.Atomic[bool] - check := CheckerFunc(func(context.Context) (interface{}, error) { + check := CheckerFunc(func(context.Context) (any, error) { if shouldCheckErr.Get() { return errUnhealthy.Error(), errUnhealthy } @@ -233,7 +233,7 @@ func TestDeadlockRegression(t *testing.T) { require.NoError(err) var lock sync.Mutex - check := CheckerFunc(func(context.Context) (interface{}, error) { + check := CheckerFunc(func(context.Context) (any, error) { lock.Lock() time.Sleep(time.Nanosecond) lock.Unlock() @@ -243,7 +243,7 @@ func TestDeadlockRegression(t *testing.T) { h.Start(t.Context(), time.Nanosecond) defer h.Stop() - for i := 0; i < 100; i++ { + for i := range 100 { lock.Lock() require.NoError(h.RegisterHealthCheck(fmt.Sprintf("check-%d", i), check)) lock.Unlock() @@ -255,7 +255,7 @@ func TestDeadlockRegression(t *testing.T) { func TestTags(t *testing.T) { require := require.New(t) - check := CheckerFunc(func(context.Context) (interface{}, error) { + check := CheckerFunc(func(context.Context) (any, error) { return "", nil }) diff --git a/api/health/result.go b/api/health/result.go index b1ead84d4491..5e9bc7743987 100644 --- a/api/health/result.go +++ b/api/health/result.go @@ -18,14 +18,14 @@ func init() { type Result struct { // Details of the HealthCheck. - Details interface{} `json:"message,omitempty"` + Details any `json:"message,omitempty"` // Error is the string representation of the error returned by the failing // HealthCheck. The value is nil if the check passed. Error *string `json:"error,omitempty"` // Timestamp of the last HealthCheck. - Timestamp time.Time `json:"timestamp,omitempty"` + Timestamp time.Time `json:"timestamp"` // Duration is the amount of time this HealthCheck last took to evaluate. Duration time.Duration `json:"duration"` diff --git a/api/health/service_test.go b/api/health/service_test.go index bdbdd76aa30e..53fe47160a28 100644 --- a/api/health/service_test.go +++ b/api/health/service_test.go @@ -18,7 +18,7 @@ import ( func TestServiceResponses(t *testing.T) { require := require.New(t) - check := CheckerFunc(func(context.Context) (interface{}, error) { + check := CheckerFunc(func(context.Context) (any, error) { return "", nil }) @@ -106,7 +106,7 @@ func TestServiceResponses(t *testing.T) { } func TestServiceTagResponse(t *testing.T) { - check := CheckerFunc(func(context.Context) (interface{}, error) { + check := CheckerFunc(func(context.Context) (any, error) { return "", nil }) diff --git a/api/info/client_test.go b/api/info/client_test.go index 65718f853c05..ba6f3aed1c68 100644 --- a/api/info/client_test.go +++ b/api/info/client_test.go @@ -19,7 +19,7 @@ type mockClient struct { onCall func() } -func (mc *mockClient) SendRequest(_ context.Context, _ string, _ interface{}, replyIntf interface{}, _ ...rpc.Option) error { +func (mc *mockClient) SendRequest(_ context.Context, _ string, _ any, replyIntf any, _ ...rpc.Option) error { reply := replyIntf.(*IsBootstrappedResponse) *reply = mc.reply mc.onCall() diff --git a/api/info/service_test.go b/api/info/service_test.go index 1be54d6df868..bf71ffdeaf6e 100644 --- a/api/info/service_test.go +++ b/api/info/service_test.go @@ -18,7 +18,7 @@ var errTest = errors.New("non-nil error") type testFactory struct{} -func (testFactory) New(logging.Logger) (interface{}, error) { return nil, nil } +func (testFactory) New(logging.Logger) (any, error) { return nil, nil } type getVMsTest struct { info *Info diff --git a/chains/manager.go b/chains/manager.go index 9ffc28d2b2ec..45a63c2cc893 100644 --- a/chains/manager.go +++ b/chains/manager.go @@ -419,7 +419,7 @@ func (m *manager) createChain(chainParams ChainParameters) { healthCheckErr := fmt.Errorf("failed to create chain on subnet %s: %w", chainParams.SubnetID, err) err := m.Health.RegisterHealthCheck( chainAlias, - health.CheckerFunc(func(context.Context) (interface{}, error) { + health.CheckerFunc(func(context.Context) (any, error) { return nil, healthCheckErr }), chainParams.SubnetID.String(), @@ -1472,7 +1472,7 @@ func (m *manager) IsBootstrapped(id ids.ID) bool { } func (m *manager) registerBootstrappedHealthChecks() error { - bootstrappedCheck := health.CheckerFunc(func(context.Context) (interface{}, error) { + bootstrappedCheck := health.CheckerFunc(func(context.Context) (any, error) { if subnetIDs := m.Subnets.Bootstrapping(); len(subnetIDs) != 0 { return subnetIDs, errNotBootstrapped } @@ -1491,7 +1491,7 @@ func (m *manager) registerBootstrappedHealthChecks() error { return nil } - partialSyncCheck := health.CheckerFunc(func(context.Context) (interface{}, error) { + partialSyncCheck := health.CheckerFunc(func(context.Context) (any, error) { // Note: The health check is skipped during bootstrapping to allow a // node to sync the network even if it was previously a validator. if !m.IsBootstrapped(constants.PlatformChainID) { diff --git a/codec/codec.go b/codec/codec.go index 1afc3c3fb9ae..2767a6e054e0 100644 --- a/codec/codec.go +++ b/codec/codec.go @@ -20,9 +20,9 @@ var ( // Codec marshals and unmarshals type Codec interface { - MarshalInto(interface{}, *wrappers.Packer) error - UnmarshalFrom(*wrappers.Packer, interface{}) error + MarshalInto(any, *wrappers.Packer) error + UnmarshalFrom(*wrappers.Packer, any) error // Returns the size, in bytes, of [value] when it's marshaled - Size(value interface{}) (int, error) + Size(value any) (int, error) } diff --git a/codec/codectest/codectest.go b/codec/codectest/codectest.go index 3963de25dbec..fd275b1ffe30 100644 --- a/codec/codectest/codectest.go +++ b/codec/codectest/codectest.go @@ -122,39 +122,39 @@ type MyInnerStruct3 struct { } type myStruct struct { - InnerStruct MyInnerStruct `serialize:"true"` - InnerStruct2 *MyInnerStruct `serialize:"true"` - Member1 int64 `serialize:"true"` - Member2 uint16 `serialize:"true"` - MyArray2 [5]string `serialize:"true"` - MyArray3 [3]MyInnerStruct `serialize:"true"` - MyArray4 [2]*MyInnerStruct2 `serialize:"true"` - MySlice []byte `serialize:"true"` - MySlice2 []string `serialize:"true"` - MySlice3 []MyInnerStruct `serialize:"true"` - MySlice4 []*MyInnerStruct2 `serialize:"true"` - MyArray [4]byte `serialize:"true"` - MyInterface Foo `serialize:"true"` - MySlice5 []Foo `serialize:"true"` - InnerStruct3 MyInnerStruct3 `serialize:"true"` - MyPointer *Foo `serialize:"true"` - MyMap1 map[string]string `serialize:"true"` - MyMap2 map[int32][]MyInnerStruct3 `serialize:"true"` - MyMap3 map[MyInnerStruct2][]int32 `serialize:"true"` - MyMap4 map[int32]*int32 `serialize:"true"` - MyMap5 map[int32]int32 `serialize:"true"` - MyMap6 map[[5]int32]int32 `serialize:"true"` - MyMap7 map[interface{}]interface{} `serialize:"true"` - Uint8 uint8 `serialize:"true"` - Int8 int8 `serialize:"true"` - Uint16 uint16 `serialize:"true"` - Int16 int16 `serialize:"true"` - Uint32 uint32 `serialize:"true"` - Int32 int32 `serialize:"true"` - Uint64 uint64 `serialize:"true"` - Int64 int64 `serialize:"true"` - Bool bool `serialize:"true"` - String string `serialize:"true"` + InnerStruct MyInnerStruct `serialize:"true"` + InnerStruct2 *MyInnerStruct `serialize:"true"` + Member1 int64 `serialize:"true"` + Member2 uint16 `serialize:"true"` + MyArray2 [5]string `serialize:"true"` + MyArray3 [3]MyInnerStruct `serialize:"true"` + MyArray4 [2]*MyInnerStruct2 `serialize:"true"` + MySlice []byte `serialize:"true"` + MySlice2 []string `serialize:"true"` + MySlice3 []MyInnerStruct `serialize:"true"` + MySlice4 []*MyInnerStruct2 `serialize:"true"` + MyArray [4]byte `serialize:"true"` + MyInterface Foo `serialize:"true"` + MySlice5 []Foo `serialize:"true"` + InnerStruct3 MyInnerStruct3 `serialize:"true"` + MyPointer *Foo `serialize:"true"` + MyMap1 map[string]string `serialize:"true"` + MyMap2 map[int32][]MyInnerStruct3 `serialize:"true"` + MyMap3 map[MyInnerStruct2][]int32 `serialize:"true"` + MyMap4 map[int32]*int32 `serialize:"true"` + MyMap5 map[int32]int32 `serialize:"true"` + MyMap6 map[[5]int32]int32 `serialize:"true"` + MyMap7 map[any]any `serialize:"true"` + Uint8 uint8 `serialize:"true"` + Int8 int8 `serialize:"true"` + Uint16 uint16 `serialize:"true"` + Int16 int16 `serialize:"true"` + Uint32 uint32 `serialize:"true"` + Int32 int32 `serialize:"true"` + Uint64 uint64 `serialize:"true"` + Int64 int64 `serialize:"true"` + Bool bool `serialize:"true"` + String string `serialize:"true"` } // Test marshaling/unmarshaling a complicated struct @@ -176,7 +176,7 @@ func TestStruct(t testing.TB, codec codecpkg.GeneralCodec) { myMap6[[5]int32{0, 1, 2, 3, 4}] = 1 myMap6[[5]int32{1, 2, 3, 4, 5}] = 2 - myMap7 := make(map[interface{}]interface{}) + myMap7 := make(map[any]any) myMap7["key"] = "value" myMap7[int32(1)] = int32(2) diff --git a/codec/hierarchycodec/codec.go b/codec/hierarchycodec/codec.go index 6e61018a5562..cc13dd4e8e46 100644 --- a/codec/hierarchycodec/codec.go +++ b/codec/hierarchycodec/codec.go @@ -77,7 +77,7 @@ func (c *hierarchyCodec) NextGroup() { // RegisterType is used to register types that may be unmarshaled into an interface // [val] is a value of the type being registered -func (c *hierarchyCodec) RegisterType(val interface{}) error { +func (c *hierarchyCodec) RegisterType(val any) error { c.lock.Lock() defer c.lock.Unlock() diff --git a/codec/linearcodec/codec.go b/codec/linearcodec/codec.go index dfa485001ec1..17d32f22e505 100644 --- a/codec/linearcodec/codec.go +++ b/codec/linearcodec/codec.go @@ -62,7 +62,7 @@ func (c *linearCodec) SkipRegistrations(num int) { // RegisterType is used to register types that may be unmarshaled into an interface // [val] is a value of the type being registered -func (c *linearCodec) RegisterType(val interface{}) error { +func (c *linearCodec) RegisterType(val any) error { c.lock.Lock() defer c.lock.Unlock() diff --git a/codec/manager.go b/codec/manager.go index ea6b23aaa4bd..f2a5bcff9774 100644 --- a/codec/manager.go +++ b/codec/manager.go @@ -46,16 +46,16 @@ type Manager interface { // using the codec with the given version. // RegisterCodec must have been called with that version. // If [value] is nil, returns [ErrMarshalNil] - Size(version uint16, value interface{}) (int, error) + Size(version uint16, value any) (int, error) // Marshal the given value using the codec with the given version. // RegisterCodec must have been called with that version. - Marshal(version uint16, source interface{}) (destination []byte, err error) + Marshal(version uint16, source any) (destination []byte, err error) // Unmarshal the given bytes into the given destination. [destination] must // be a pointer or an interface. Returns the version of the codec that // produces the given bytes. - Unmarshal(source []byte, destination interface{}) (version uint16, err error) + Unmarshal(source []byte, destination any) (version uint16, err error) } // NewManager returns a new codec manager. @@ -90,7 +90,7 @@ func (m *manager) RegisterCodec(version uint16, codec Codec) error { return nil } -func (m *manager) Size(version uint16, value interface{}) (int, error) { +func (m *manager) Size(version uint16, value any) (int, error) { if value == nil { return 0, ErrMarshalNil // can't marshal nil } @@ -110,7 +110,7 @@ func (m *manager) Size(version uint16, value interface{}) (int, error) { } // To marshal an interface, [value] must be a pointer to the interface. -func (m *manager) Marshal(version uint16, value interface{}) ([]byte, error) { +func (m *manager) Marshal(version uint16, value any) ([]byte, error) { if value == nil { return nil, ErrMarshalNil // can't marshal nil } @@ -135,7 +135,7 @@ func (m *manager) Marshal(version uint16, value interface{}) ([]byte, error) { // Unmarshal unmarshals [bytes] into [dest], where [dest] must be a pointer or // interface. -func (m *manager) Unmarshal(bytes []byte, dest interface{}) (uint16, error) { +func (m *manager) Unmarshal(bytes []byte, dest any) (uint16, error) { if dest == nil { return 0, ErrUnmarshalNil } diff --git a/codec/reflectcodec/struct_fielder.go b/codec/reflectcodec/struct_fielder.go index 0b43fbfdba70..7a542e00d355 100644 --- a/codec/reflectcodec/struct_fielder.go +++ b/codec/reflectcodec/struct_fielder.go @@ -59,7 +59,7 @@ func (s *structFielder) GetSerializedFields(t reflect.Type) ([]int, error) { numFields := t.NumField() serializedFields := make([]int, 0, numFields) - for i := 0; i < numFields; i++ { // Go through all fields of this struct + for i := range numFields { // Go through all fields of this struct field := t.Field(i) // Multiple tags per fields can be specified. diff --git a/codec/reflectcodec/type_codec.go b/codec/reflectcodec/type_codec.go index c092f43328d7..4502cb78f2e8 100644 --- a/codec/reflectcodec/type_codec.go +++ b/codec/reflectcodec/type_codec.go @@ -80,7 +80,7 @@ func New(typer TypeCodec, tagNames []string) codec.Codec { } } -func (c *genericCodec) Size(value interface{}) (int, error) { +func (c *genericCodec) Size(value any) (int, error) { if value == nil { return 0, codec.ErrMarshalNil } @@ -290,7 +290,7 @@ func (c *genericCodec) size( } // To marshal an interface, [value] must be a pointer to the interface -func (c *genericCodec) MarshalInto(value interface{}, p *wrappers.Packer) error { +func (c *genericCodec) MarshalInto(value any, p *wrappers.Packer) error { if value == nil { return codec.ErrMarshalNil } @@ -387,7 +387,7 @@ func (c *genericCodec) marshal( p.PackFixedBytes(value.Bytes()) return p.Err } - for i := 0; i < numElts; i++ { // Process each element in the slice + for i := range numElts { // Process each element in the slice startOffset := p.Offset if err := c.marshal(value.Index(i), p, typeStack); err != nil { return err @@ -403,7 +403,7 @@ func (c *genericCodec) marshal( return p.Err } numElts := value.Len() - for i := 0; i < numElts; i++ { // Process each element in the array + for i := range numElts { // Process each element in the array if err := c.marshal(value.Index(i), p, typeStack); err != nil { return err } @@ -497,7 +497,7 @@ func (c *genericCodec) marshal( // UnmarshalFrom unmarshals [p.Bytes] into [dest], where [dest] must be a pointer or // interface -func (c *genericCodec) UnmarshalFrom(p *wrappers.Packer, dest interface{}) error { +func (c *genericCodec) UnmarshalFrom(p *wrappers.Packer, dest any) error { if dest == nil { return codec.ErrUnmarshalNil } @@ -598,7 +598,7 @@ func (c *genericCodec) unmarshal( // Unmarshal each element and append it into the slice. value.Set(reflect.MakeSlice(sliceType, 0, initialSliceLen)) zeroValue := reflect.Zero(innerType) - for i := 0; i < numElts; i++ { + for i := range numElts { value.Set(reflect.Append(value, zeroValue)) startOffset := p.Offset @@ -622,7 +622,7 @@ func (c *genericCodec) unmarshal( copy(underlyingSlice, unpackedBytes) return nil } - for i := 0; i < numElts; i++ { + for i := range numElts { if err := c.unmarshal(p, value.Index(i), typeStack); err != nil { return err } @@ -702,7 +702,7 @@ func (c *genericCodec) unmarshal( // Set [value] to be a new map of the appropriate type. value.Set(reflect.MakeMap(mapType)) - for i := 0; i < numElts; i++ { + for i := range numElts { mapKey := reflect.New(mapKeyType).Elem() keyStartOffset := p.Offset diff --git a/codec/registry.go b/codec/registry.go index eb5044ddc365..0eaa2ce34b42 100644 --- a/codec/registry.go +++ b/codec/registry.go @@ -9,5 +9,5 @@ var ErrDuplicateType = errors.New("duplicate type registration") // Registry registers new types that can be marshaled into type Registry interface { - RegisterType(interface{}) error + RegisterType(any) error } diff --git a/config/config.go b/config/config.go index 9185b4b60345..694179bb16dd 100644 --- a/config/config.go +++ b/config/config.go @@ -1549,9 +1549,9 @@ func GetNodeConfig(v *viper.Viper) (node.Config, error) { return nodeConfig, nil } -func providedFlags(v *viper.Viper) map[string]interface{} { +func providedFlags(v *viper.Viper) map[string]any { settings := v.AllSettings() - customSettings := make(map[string]interface{}, len(settings)) + customSettings := make(map[string]any, len(settings)) for key, val := range settings { if v.IsSet(key) { customSettings[key] = val diff --git a/config/node/config.go b/config/node/config.go index 2efd632492b1..0f85ac5d324d 100644 --- a/config/node/config.go +++ b/config/node/config.go @@ -221,7 +221,7 @@ type Config struct { UseCurrentHeight bool `json:"useCurrentHeight"` // ProvidedFlags contains all the flags set by the user - ProvidedFlags map[string]interface{} `json:"-"` + ProvidedFlags map[string]any `json:"-"` // ChainDataDir is the root path for per-chain directories where VMs can // write arbitrary data. diff --git a/database/corruptabledb/db.go b/database/corruptabledb/db.go index 1af09a152a17..5515881b8797 100644 --- a/database/corruptabledb/db.go +++ b/database/corruptabledb/db.go @@ -82,7 +82,7 @@ func (db *Database) Close() error { return db.handleError(db.Database.Close()) } -func (db *Database) HealthCheck(ctx context.Context) (interface{}, error) { +func (db *Database) HealthCheck(ctx context.Context) (any, error) { if err := db.corrupted(); err != nil { return nil, err } diff --git a/database/dbtest/benchmark.go b/database/dbtest/benchmark.go index 0abc82b4fbe6..799d094f49fb 100644 --- a/database/dbtest/benchmark.go +++ b/database/dbtest/benchmark.go @@ -43,7 +43,7 @@ func SetupBenchmark(b *testing.B, count int, keySize, valueSize int) ([][]byte, keys := make([][]byte, count) values := make([][]byte, count) - for i := 0; i < count; i++ { + for i := range count { keyBytes := make([]byte, keySize) valueBytes := make([]byte, valueSize) _, err := rand.Read(keyBytes) // #nosec G404 diff --git a/database/dbtest/dbtest.go b/database/dbtest/dbtest.go index b9ed8f26ad57..d650a782f0c2 100644 --- a/database/dbtest/dbtest.go +++ b/database/dbtest/dbtest.go @@ -485,7 +485,7 @@ func TestBatchReplay(t *testing.T, db database.Database) { require.NoError(batch.Delete(key2)) require.NoError(batch.Put(key1, value2)) - for i := 0; i < 2; i++ { + for range 2 { mockBatch := databasemock.NewBatch(ctrl) gomock.InOrder( mockBatch.EXPECT().Put(key1, value1).Times(1), @@ -1164,12 +1164,12 @@ func runConcurrentBatches( valueSize int, ) error { batches := make([]database.Batch, 0, numBatches) - for i := 0; i < numBatches; i++ { + for range numBatches { batches = append(batches, db.NewBatch()) } for _, batch := range batches { - for i := 0; i < keysPerBatch; i++ { + for range keysPerBatch { key := utils.RandomBytes(keySize) value := utils.RandomBytes(valueSize) if err := batch.Put(key, value); err != nil { diff --git a/database/leveldb/db.go b/database/leveldb/db.go index 4a4591b0631e..21606b2e0af2 100644 --- a/database/leveldb/db.go +++ b/database/leveldb/db.go @@ -361,7 +361,7 @@ func (db *Database) Close() error { return updateError(db.DB.Close()) } -func (db *Database) HealthCheck(context.Context) (interface{}, error) { +func (db *Database) HealthCheck(context.Context) (any, error) { if db.closed.Get() { return nil, database.ErrClosed } diff --git a/database/memdb/db.go b/database/memdb/db.go index afa532d6be9c..cb6bbba393d3 100644 --- a/database/memdb/db.go +++ b/database/memdb/db.go @@ -164,7 +164,7 @@ func (db *Database) Compact(_, _ []byte) error { return nil } -func (db *Database) HealthCheck(context.Context) (interface{}, error) { +func (db *Database) HealthCheck(context.Context) (any, error) { if db.isClosed() { return nil, database.ErrClosed } diff --git a/database/merkle/sync/sync_test.go b/database/merkle/sync/sync_test.go index 9f5a9cbcd0a3..5a0b2ca9a1a7 100644 --- a/database/merkle/sync/sync_test.go +++ b/database/merkle/sync/sync_test.go @@ -52,7 +52,7 @@ func Test_Midpoint(t *testing.T) { mid = midPoint(maybe.Some([]byte{255}), maybe.Nothing[[]byte]()) require.Equal(maybe.Some([]byte{255, 127, 127}), mid) - for i := 0; i < 5000; i++ { + for i := range 5000 { r := rand.New(rand.NewSource(int64(i))) start := make([]byte, r.Intn(99)+1) diff --git a/database/merkle/sync/syncer.go b/database/merkle/sync/syncer.go index 5ec175e9344a..7211cd053bf3 100644 --- a/database/merkle/sync/syncer.go +++ b/database/merkle/sync/syncer.go @@ -137,7 +137,7 @@ type Syncer[R any, C any] struct { syncing bool closeOnce sync.Once - stateSyncNodeIdx uint32 + stateSyncNodeIdx atomic.Uint32 metrics SyncMetrics } @@ -470,7 +470,7 @@ func (s *Syncer[_, _]) sendRequest( // Get the next nodeID to query using the [nodeIdx] offset. // If we're out of nodes, loop back to 0. // We do this try to query a different node each time if possible. - nodeIdx := atomic.AddUint32(&s.stateSyncNodeIdx, 1) + nodeIdx := s.stateSyncNodeIdx.Add(1) nodeID := s.config.StateSyncNodes[nodeIdx%uint32(len(s.config.StateSyncNodes))] return client.AppRequest(ctx, set.Of(nodeID), requestBytes, onResponse) } diff --git a/database/merkle/sync/workheap_test.go b/database/merkle/sync/workheap_test.go index 81c84359b7f6..f72d00d2ed11 100644 --- a/database/merkle/sync/workheap_test.go +++ b/database/merkle/sync/workheap_test.go @@ -193,7 +193,7 @@ func TestWorkHeapMergeInsertRandom(t *testing.T) { t.Logf("seed: %d", seed) // Create start and end bounds - for i := 0; i < numRanges; i++ { + for range numRanges { bound := make([]byte, 32) _, _ = rand.Read(bound) bounds = append(bounds, bound) diff --git a/database/meterdb/db.go b/database/meterdb/db.go index 7a4d0b6f7a7a..af1584a9de5c 100644 --- a/database/meterdb/db.go +++ b/database/meterdb/db.go @@ -237,7 +237,7 @@ func (db *Database) Close() error { return err } -func (db *Database) HealthCheck(ctx context.Context) (interface{}, error) { +func (db *Database) HealthCheck(ctx context.Context) (any, error) { start := time.Now() result, err := db.db.HealthCheck(ctx) duration := time.Since(start) diff --git a/database/pebbledb/db.go b/database/pebbledb/db.go index a2b8dfd2f3c5..679583f5f9a7 100644 --- a/database/pebbledb/db.go +++ b/database/pebbledb/db.go @@ -120,7 +120,7 @@ func (db *Database) Close() error { return updateError(db.pebbleDB.Close()) } -func (db *Database) HealthCheck(_ context.Context) (interface{}, error) { +func (db *Database) HealthCheck(_ context.Context) (any, error) { db.lock.RLock() defer db.lock.RUnlock() @@ -290,8 +290,8 @@ func keyRange(start, prefix []byte) *pebble.IterOptions { // Assumes the Database uses bytes.Compare for key comparison and not a custom // comparer. func prefixToUpperBound(prefix []byte) []byte { - for i := len(prefix) - 1; i >= 0; i-- { - if prefix[i] != 0xFF { + for i, v := range slices.Backward(prefix) { + if v != 0xFF { upperBound := make([]byte, i+1) copy(upperBound, prefix) upperBound[i]++ diff --git a/database/prefixdb/db.go b/database/prefixdb/db.go index e05ac8a19be0..3817c5859209 100644 --- a/database/prefixdb/db.go +++ b/database/prefixdb/db.go @@ -232,7 +232,7 @@ func (db *Database) isClosed() bool { return db.closed } -func (db *Database) HealthCheck(ctx context.Context) (interface{}, error) { +func (db *Database) HealthCheck(ctx context.Context) (any, error) { db.lock.RLock() defer db.lock.RUnlock() diff --git a/database/rpcdb/db_client.go b/database/rpcdb/db_client.go index a74ae659dc79..f5be2b5a3f74 100644 --- a/database/rpcdb/db_client.go +++ b/database/rpcdb/db_client.go @@ -6,6 +6,7 @@ package rpcdb import ( "context" "encoding/json" + "slices" "sync" "google.golang.org/protobuf/types/known/emptypb" @@ -133,7 +134,7 @@ func (db *DatabaseClient) Close() error { return ErrEnumToError[resp.Err] } -func (db *DatabaseClient) HealthCheck(ctx context.Context) (interface{}, error) { +func (db *DatabaseClient) HealthCheck(ctx context.Context) (any, error) { health, err := db.client.HealthCheck(ctx, &emptypb.Empty{}) if err != nil { return nil, err @@ -151,8 +152,8 @@ type batch struct { func (b *batch) Write() error { request := &rpcdbpb.WriteBatchRequest{} keySet := set.NewSet[string](len(b.Ops)) - for i := len(b.Ops) - 1; i >= 0; i-- { - op := b.Ops[i] + for _, v := range slices.Backward(b.Ops) { + op := v key := string(op.Key) if keySet.Contains(key) { continue diff --git a/database/versiondb/db.go b/database/versiondb/db.go index 12fe263c9a70..ec33637edc1a 100644 --- a/database/versiondb/db.go +++ b/database/versiondb/db.go @@ -263,7 +263,7 @@ func (db *Database) isClosed() bool { return db.db == nil } -func (db *Database) HealthCheck(ctx context.Context) (interface{}, error) { +func (db *Database) HealthCheck(ctx context.Context) (any, error) { db.lock.RLock() defer db.lock.RUnlock() diff --git a/graft/coreth/cmd/simulator/txs/tx_generator.go b/graft/coreth/cmd/simulator/txs/tx_generator.go index 5a8cdc2a4f44..528ddb0cb87d 100644 --- a/graft/coreth/cmd/simulator/txs/tx_generator.go +++ b/graft/coreth/cmd/simulator/txs/tx_generator.go @@ -60,7 +60,7 @@ func addTxs(ctx context.Context, txSequence *txSequence, generator CreateTx, cli if err != nil { return err } - for i := uint64(0); i < numTxs; i++ { + for i := range numTxs { tx, err := generator(key, startingNonce+i) if err != nil { return err diff --git a/graft/coreth/core/blockchain_ext_test.go b/graft/coreth/core/blockchain_ext_test.go index 6f8a263112b4..409fe2e38fd0 100644 --- a/graft/coreth/core/blockchain_ext_test.go +++ b/graft/coreth/core/blockchain_ext_test.go @@ -357,7 +357,7 @@ func InsertLongForkedChainTest(t *testing.T, create createFunc) { require.Equal(len(chain1)+len(chain2), blockchain.snaps.NumBlockLayers(), "incorrect snapshot layer count") } - for i := 0; i < len(chain2); i++ { + for i := range chain2 { require.NoError(blockchain.Reject(chain2[i])) if blockchain.snaps != nil { @@ -467,7 +467,7 @@ func AcceptNonCanonicalBlockTest(t *testing.T, create createFunc) { require.NoError(blockchain.Accept(chain2[0])) blockchain.DrainAcceptorQueue() - for i := 0; i < len(chain1); i++ { + for i := range chain1 { require.NoError(blockchain.Reject(chain1[i])) require.False(blockchain.HasBlock(chain1[i].Hash(), chain1[i].NumberU64())) } diff --git a/graft/coreth/core/extstate/statedb_multicoin_test.go b/graft/coreth/core/extstate/statedb_multicoin_test.go index e3d18d70bf78..b864c2d9826e 100644 --- a/graft/coreth/core/extstate/statedb_multicoin_test.go +++ b/graft/coreth/core/extstate/statedb_multicoin_test.go @@ -101,7 +101,7 @@ func TestMultiCoinSnapshot(t *testing.T) { assertBalances(t, wrappedStateDB, 10, 10, 0) // Add more layers than the cap and ensure the balances and layers are correct - for i := 0; i < 256; i++ { + for i := range 256 { statedb, err = state.New(root, db, snapTree) require.NoErrorf(t, err, "creating statedb %d", i) diff --git a/graft/coreth/core/state_manager_test.go b/graft/coreth/core/state_manager_test.go index d926a66b33a6..b034744b0586 100644 --- a/graft/coreth/core/state_manager_test.go +++ b/graft/coreth/core/state_manager_test.go @@ -82,7 +82,7 @@ func TestNoPruningTrieWriter(t *testing.T) { m := &MockTrieDB{} w := NewTrieWriter(m, &CacheConfig{}) require := require.New(t) - for i := 0; i < tipBufferSize+1; i++ { + for i := range tipBufferSize + 1 { bigI := big.NewInt(int64(i)) block := types.NewBlock( &types.Header{ diff --git a/graft/coreth/core/state_processor_ext.go b/graft/coreth/core/state_processor_ext.go index 7c267282a55e..74fcb66c96b1 100644 --- a/graft/coreth/core/state_processor_ext.go +++ b/graft/coreth/core/state_processor_ext.go @@ -44,7 +44,7 @@ func ApplyPrecompileActivations(c *params.ChainConfig, parentTimestamp *uint64, statedb.Finalise(true) continue } - var printIntf interface{} + var printIntf any marshalled, err := json.Marshal(activatingConfig) if err == nil { printIntf = string(marshalled) diff --git a/graft/coreth/eth/gasprice/fee_info_provider_test.go b/graft/coreth/eth/gasprice/fee_info_provider_test.go index e3a80bf012d5..cda055ff35ad 100644 --- a/graft/coreth/eth/gasprice/fee_info_provider_test.go +++ b/graft/coreth/eth/gasprice/fee_info_provider_test.go @@ -56,7 +56,7 @@ func TestFeeInfoProviderCacheSize(t *testing.T) { } // these numbers should be evicted - for i := 0; i < overflow; i++ { + for i := range overflow { feeInfo, ok := f.get(uint64(i)) require.False(t, ok) require.Nil(t, feeInfo) diff --git a/graft/coreth/internal/ethapi/api_extra.go b/graft/coreth/internal/ethapi/api_extra.go index 9c91565ad994..999c5b8a2d64 100644 --- a/graft/coreth/internal/ethapi/api_extra.go +++ b/graft/coreth/internal/ethapi/api_extra.go @@ -61,10 +61,10 @@ func (s *BlockChainAPI) CallDetailed(ctx context.Context, args TransactionArgs, // // BadBlockArgs represents the entries in the list returned when bad blocks are queried. type BadBlockArgs struct { - Hash common.Hash `json:"hash"` - Block map[string]interface{} `json:"block"` - RLP string `json:"rlp"` - Reason *core.BadBlockReason `json:"reason"` + Hash common.Hash `json:"hash"` + Block map[string]any `json:"block"` + RLP string `json:"rlp"` + Reason *core.BadBlockReason `json:"reason"` } // GetBadBlocks returns a list of the last 'bad blocks' that the client has seen on the network @@ -77,7 +77,7 @@ func (s *BlockChainAPI) GetBadBlocks(context.Context) ([]*BadBlockArgs, error) { for i, block := range badBlocks { var ( blockRlp string - blockJSON map[string]interface{} + blockJSON map[string]any ) if rlpBytes, err := rlp.EncodeToBytes(block); err != nil { blockRlp = err.Error() // Hacky, but hey, it works diff --git a/graft/coreth/network/network_test.go b/graft/coreth/network/network_test.go index 828e129c09e8..e58fed87979d 100644 --- a/graft/coreth/network/network_test.go +++ b/graft/coreth/network/network_test.go @@ -250,13 +250,11 @@ func TestAppRequestOnShutdown(t *testing.T) { ) sender := testAppSender{ sendAppRequestFn: func(context.Context, set.Set[ids.NodeID], uint32, []byte) error { - wg.Add(1) - go func() { + wg.Go(func() { called = true // shutdown the network here to ensure any outstanding requests are handled as failed net.Shutdown() - wg.Done() - }() // this is on a goroutine to avoid a deadlock since calling Shutdown takes the lock. + }) // this is on a goroutine to avoid a deadlock since calling Shutdown takes the lock. return nil }, } @@ -600,7 +598,7 @@ func TestNetworkRouting(t *testing.T) { require.ErrorIs(err, p2p.ErrUnrequestedResponse) } -func buildCodec(t *testing.T, types ...interface{}) codec.Manager { +func buildCodec(t *testing.T, types ...any) codec.Manager { codecManager := codec.NewDefaultManager() c := linearcodec.NewDefault() for _, typ := range types { @@ -612,7 +610,7 @@ func buildCodec(t *testing.T, types ...interface{}) codec.Manager { // marshalStruct is a helper method used to marshal an object as `interface{}` // so that the codec is able to include the TypeID in the resulting bytes -func marshalStruct(codec codec.Manager, obj interface{}) ([]byte, error) { +func marshalStruct(codec codec.Manager, obj any) ([]byte, error) { return codec.Marshal(codecVersion, &obj) } diff --git a/graft/coreth/network/peer_tracker_test.go b/graft/coreth/network/peer_tracker_test.go index aa6061c55d5e..1e938da9b6e2 100644 --- a/graft/coreth/network/peer_tracker_test.go +++ b/graft/coreth/network/peer_tracker_test.go @@ -55,7 +55,7 @@ func TestPeerTracker(t *testing.T) { // Expect requests to go to responsive or new peers, so long as they are available numRequests := 50 - for i := 0; i < numRequests; i++ { + for i := range numRequests { peer, ok, err := p.GetAnyPeer(nil) require.NoError(err) require.True(ok) diff --git a/graft/coreth/params/config_extra.go b/graft/coreth/params/config_extra.go index b96194534f8c..c0acaa41dc02 100644 --- a/graft/coreth/params/config_extra.go +++ b/graft/coreth/params/config_extra.go @@ -112,7 +112,7 @@ func WithExtra(c *ChainConfig, extra *extras.ChainConfig) *ChainConfig { type ChainConfigWithUpgradesJSON struct { ChainConfig - UpgradeConfig extras.UpgradeConfig `json:"upgrades,omitempty"` + UpgradeConfig extras.UpgradeConfig `json:"upgrades"` } // MarshalJSON implements json.Marshaler. This is a workaround for the fact that diff --git a/graft/coreth/plugin/evm/atomic/atomictest/tx.go b/graft/coreth/plugin/evm/atomic/atomictest/tx.go index a6d229016ef1..9cb2a0284fc1 100644 --- a/graft/coreth/plugin/evm/atomic/atomictest/tx.go +++ b/graft/coreth/plugin/evm/atomic/atomictest/tx.go @@ -162,7 +162,7 @@ func NewTestTx() *atomic.Tx { func NewTestTxs(numTxs int) []*atomic.Tx { txs := make([]*atomic.Tx, 0, numTxs) - for i := 0; i < numTxs; i++ { + for range numTxs { txs = append(txs, NewTestTx()) } diff --git a/graft/coreth/plugin/evm/atomic/export_tx.go b/graft/coreth/plugin/evm/atomic/export_tx.go index 1b50957c1940..647525c07490 100644 --- a/graft/coreth/plugin/evm/atomic/export_tx.go +++ b/graft/coreth/plugin/evm/atomic/export_tx.go @@ -469,10 +469,7 @@ func getSpendableAVAXWithFee( // Use the entire [balance] as an input, but if the required [amount] // is less than the balance, update the [inputAmount] to spend the // minimum amount to finish the transaction. - inputAmount := balance - if amount < balance { - inputAmount = amount - } + inputAmount := min(amount, balance) nonce := state.GetNonce(addr) inputs = append(inputs, EVMInput{ diff --git a/graft/coreth/plugin/evm/atomic/state/atomic_repository_test.go b/graft/coreth/plugin/evm/atomic/state/atomic_repository_test.go index 60e9c89ec5e6..4bafd56a76ad 100644 --- a/graft/coreth/plugin/evm/atomic/state/atomic_repository_test.go +++ b/graft/coreth/plugin/evm/atomic/state/atomic_repository_test.go @@ -29,7 +29,7 @@ import ( func addTxs(t testing.TB, codec codec.Manager, acceptedAtomicTxDB database.Database, fromHeight uint64, toHeight uint64, txsPerHeight int, txMap map[uint64][]*atomic.Tx) { for height := fromHeight; height < toHeight; height++ { txs := make([]*atomic.Tx, 0, txsPerHeight) - for i := 0; i < txsPerHeight; i++ { + for range txsPerHeight { tx := atomictest.NewTestTx() txs = append(txs, tx) txBytes, err := codec.Marshal(atomic.CodecVersion, tx) @@ -92,7 +92,7 @@ func verifyTxs(t testing.TB, repo *AtomicRepository, txMap map[uint64][]*atomic. utils.Sort(expectedTxs) txIDs := set.Set[ids.ID]{} - for i := 0; i < len(txs); i++ { + for i := range txs { require.Equalf(t, expectedTxs[i].ID().Hex(), txs[i].ID().Hex(), "wrong txID at height=%d idx=%d", height, i) txIDs.Add(txs[i].ID()) } diff --git a/graft/coreth/plugin/evm/atomic/status.go b/graft/coreth/plugin/evm/atomic/status.go index 714e7d516a37..9a7fa43d16c2 100644 --- a/graft/coreth/plugin/evm/atomic/status.go +++ b/graft/coreth/plugin/evm/atomic/status.go @@ -30,7 +30,7 @@ func (s Status) MarshalJSON() ([]byte, error) { if err := s.Valid(); err != nil { return nil, err } - return []byte(fmt.Sprintf("%q", s)), nil + return fmt.Appendf(nil, "%q", s), nil } // UnmarshalJSON ... diff --git a/graft/coreth/plugin/evm/atomic/txpool/mempool_test.go b/graft/coreth/plugin/evm/atomic/txpool/mempool_test.go index 2f7e4215c2a5..0577ae9e0c52 100644 --- a/graft/coreth/plugin/evm/atomic/txpool/mempool_test.go +++ b/graft/coreth/plugin/evm/atomic/txpool/mempool_test.go @@ -29,7 +29,7 @@ func TestMempoolAddTx(t *testing.T) { require.NoError(err) txs := make([]*atomic.Tx, 0) - for i := 0; i < 3_000; i++ { + for range 3_000 { tx := atomictest.GenerateTestImportTxWithGas(1, 1) txs = append(txs, tx) require.NoError(m.Add(tx)) diff --git a/graft/coreth/plugin/evm/atomic/txpool/tx_heap.go b/graft/coreth/plugin/evm/atomic/txpool/tx_heap.go index be17d7be8d58..fc30d5bf4cfb 100644 --- a/graft/coreth/plugin/evm/atomic/txpool/tx_heap.go +++ b/graft/coreth/plugin/evm/atomic/txpool/tx_heap.go @@ -49,7 +49,7 @@ func (th internalTxHeap) Swap(i, j int) { th.items[j].index = j } -func (th *internalTxHeap) Push(x interface{}) { +func (th *internalTxHeap) Push(x any) { entry := x.(*txEntry) if th.Has(entry.id) { return @@ -58,7 +58,7 @@ func (th *internalTxHeap) Push(x interface{}) { th.lookup[entry.id] = entry } -func (th *internalTxHeap) Pop() interface{} { +func (th *internalTxHeap) Pop() any { n := len(th.items) item := th.items[n-1] th.items[n-1] = nil // avoid memory leak diff --git a/graft/coreth/plugin/evm/atomic/vm/vm.go b/graft/coreth/plugin/evm/atomic/vm/vm.go index 9aa08bef2d2c..65e31598dd53 100644 --- a/graft/coreth/plugin/evm/atomic/vm/vm.go +++ b/graft/coreth/plugin/evm/atomic/vm/vm.go @@ -293,17 +293,13 @@ func (vm *VM) onNormalOperationsStarted() error { ctx, cancel := context.WithCancel(context.TODO()) vm.cancel = cancel - vm.shutdownWg.Add(1) - go func() { + vm.shutdownWg.Go(func() { avalanchegossip.Every(ctx, vm.Ctx.Log, vm.AtomicTxPushGossiper, vm.InnerVM.Config().PushGossipFrequency.Duration) - vm.shutdownWg.Done() - }() + }) - vm.shutdownWg.Add(1) - go func() { + vm.shutdownWg.Go(func() { avalanchegossip.Every(ctx, vm.Ctx.Log, vm.pullGossiper, vm.InnerVM.Config().PullGossipFrequency.Duration) - vm.shutdownWg.Done() - }() + }) return nil } diff --git a/graft/coreth/plugin/evm/atomic/vm/vm_test.go b/graft/coreth/plugin/evm/atomic/vm/vm_test.go index 85c2b3239dee..a9210b502025 100644 --- a/graft/coreth/plugin/evm/atomic/vm/vm_test.go +++ b/graft/coreth/plugin/evm/atomic/vm/vm_test.go @@ -939,7 +939,7 @@ func TestBuildBlockDoesNotExceedAtomicGasLimit(t *testing.T) { require.NoError(err) mempoolTxs := 200 - for i := 0; i < mempoolTxs; i++ { + for i := range mempoolTxs { utxo, err := addUTXO(tvm.AtomicMemory, vm.Ctx, txID, uint32(i), vm.Ctx.AVAXAssetID, importAmount, vmtest.TestShortIDAddrs[0]) require.NoError(err) @@ -990,7 +990,7 @@ func TestExtraStateChangeAtomicGasLimitExceeded(t *testing.T) { // Add enough UTXOs, such that the created import transaction will attempt to consume more gas than allowed // in ApricotPhase5. - for i := 0; i < 100; i++ { + for i := range 100 { _, err := addUTXO(tvm1.AtomicMemory, vm1.Ctx, txID, uint32(i), vm1.Ctx.AVAXAssetID, importAmount, vmtest.TestShortIDAddrs[0]) require.NoError(err) @@ -1183,7 +1183,7 @@ func testBuildApricotPhase5Block(t *testing.T, scheme string) { require.Equal(common.Hash(blk.ID()), newHead.Head.Hash()) txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { tx := types.NewTransaction(uint64(i), address, big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice*3), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(vm.Ethereum().BlockChain().Config().ChainID), key) require.NoError(err) @@ -1312,7 +1312,7 @@ func testBuildApricotPhase4Block(t *testing.T, scheme string) { txs := make([]*types.Transaction, 10) chainID := vm.Ethereum().BlockChain().Config().ChainID - for i := 0; i < 5; i++ { + for i := range 5 { tx := types.NewTransaction(uint64(i), address, big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), key) require.NoError(err) @@ -1551,7 +1551,7 @@ func TestWaitForEvent(t *testing.T) { t.Log("WaitForEvent returns when regular transactions are added to the mempool") txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { tx := types.NewTransaction(uint64(i), address, big.NewInt(10), 21000, big.NewInt(3*ap0.MinGasPrice), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(vm.Ethereum().BlockChain().Config().ChainID), key) require.NoError(t, err) diff --git a/graft/coreth/plugin/evm/config/config.go b/graft/coreth/plugin/evm/config/config.go index e21f78bf5120..dcf2f930aa14 100644 --- a/graft/coreth/plugin/evm/config/config.go +++ b/graft/coreth/plugin/evm/config/config.go @@ -213,7 +213,7 @@ func (c Config) EthAPIs() []string { } func (d *Duration) UnmarshalJSON(data []byte) (err error) { - var v interface{} + var v any if err := json.Unmarshal(data, &v); err != nil { return err } diff --git a/graft/coreth/plugin/evm/config/config_test.go b/graft/coreth/plugin/evm/config/config_test.go index 50fa6e9abb0e..4c5096482050 100644 --- a/graft/coreth/plugin/evm/config/config_test.go +++ b/graft/coreth/plugin/evm/config/config_test.go @@ -33,7 +33,7 @@ func TestUnmarshalConfig(t *testing.T) { }, { "integer durations parsed", - []byte(fmt.Sprintf(`{"api-max-duration": "%v", "continuous-profiler-frequency": "%v"}`, 1*time.Minute, 2*time.Minute)), + fmt.Appendf(nil, `{"api-max-duration": "%v", "continuous-profiler-frequency": "%v"}`, 1*time.Minute, 2*time.Minute), Config{APIMaxDuration: Duration{1 * time.Minute}, ContinuousProfilerFrequency: Duration{2 * time.Minute}}, false, }, diff --git a/graft/coreth/plugin/evm/gossip_test.go b/graft/coreth/plugin/evm/gossip_test.go index 08ef06e2ff39..230eb4d06c0c 100644 --- a/graft/coreth/plugin/evm/gossip_test.go +++ b/graft/coreth/plugin/evm/gossip_test.go @@ -117,7 +117,7 @@ func getValidEthTxs(key *ecdsa.PrivateKey, count int, gasPrice *big.Int) []*type amount := big.NewInt(0) gasLimit := uint64(37000) - for i := 0; i < count; i++ { + for i := range count { tx, _ := types.SignTx( types.NewTransaction( uint64(i), diff --git a/graft/coreth/plugin/evm/health.go b/graft/coreth/plugin/evm/health.go index 434772669e25..8fed12cf0308 100644 --- a/graft/coreth/plugin/evm/health.go +++ b/graft/coreth/plugin/evm/health.go @@ -8,7 +8,7 @@ import "context" // Health returns nil if this chain is healthy. // Also returns details, which should be one of: // string, []byte, map[string]string -func (*VM) HealthCheck(context.Context) (interface{}, error) { +func (*VM) HealthCheck(context.Context) (any, error) { // TODO perform actual health check return nil, nil } diff --git a/graft/coreth/plugin/evm/prestate_tracer_test.go b/graft/coreth/plugin/evm/prestate_tracer_test.go index 664bb03bdb20..74c39067e896 100644 --- a/graft/coreth/plugin/evm/prestate_tracer_test.go +++ b/graft/coreth/plugin/evm/prestate_tracer_test.go @@ -95,7 +95,7 @@ type testcase struct { Context *callContext `json:"context"` Input string `json:"input"` TracerConfig json.RawMessage `json:"tracerConfig"` - Result interface{} `json:"result"` + Result any `json:"result"` } type callContext struct { diff --git a/graft/coreth/plugin/evm/vm.go b/graft/coreth/plugin/evm/vm.go index 98bdd1c54c78..f087b7f46db7 100644 --- a/graft/coreth/plugin/evm/vm.go +++ b/graft/coreth/plugin/evm/vm.go @@ -776,11 +776,9 @@ func (vm *VM) initBlockBuilding() error { if err != nil { return fmt.Errorf("failed to initialize gossip eth tx pool: %w", err) } - vm.shutdownWg.Add(1) - go func() { + vm.shutdownWg.Go(func() { ethTxPool.Subscribe(ctx) - vm.shutdownWg.Done() - }() + }) handler, pullGossiper, pushGossiper, err := avalanchegossip.NewSystem( vm.ctx.NodeID, @@ -822,16 +820,12 @@ func (vm *VM) initBlockBuilding() error { return fmt.Errorf("failed to add eth tx gossip handler: %w", err) } - vm.shutdownWg.Add(1) - go func() { + vm.shutdownWg.Go(func() { avalanchegossip.Every(ctx, vm.ctx.Log, pushGossiper, vm.config.PushGossipFrequency.Duration) - vm.shutdownWg.Done() - }() - vm.shutdownWg.Add(1) - go func() { + }) + vm.shutdownWg.Go(func() { avalanchegossip.Every(ctx, vm.ctx.Log, pullGossiper, vm.config.PullGossipFrequency.Duration) - vm.shutdownWg.Done() - }() + }) return nil } @@ -1105,15 +1099,13 @@ func (vm *VM) startContinuousProfiler() { ) defer vm.profiler.Shutdown() - vm.shutdownWg.Add(1) - go func() { - defer vm.shutdownWg.Done() + vm.shutdownWg.Go(func() { log.Info("Dispatching continuous profiler", "dir", vm.config.ContinuousProfilerDir, "freq", vm.config.ContinuousProfilerFrequency, "maxFiles", vm.config.ContinuousProfilerMaxFiles) err := vm.profiler.Dispatch() if err != nil { log.Error("continuous profiler failed", "err", err) } - }() + }) // Wait for shutdownChan to be closed <-vm.shutdownChan } diff --git a/graft/coreth/plugin/evm/vm_test.go b/graft/coreth/plugin/evm/vm_test.go index 4f255bda4326..60025acbadea 100644 --- a/graft/coreth/plugin/evm/vm_test.go +++ b/graft/coreth/plugin/evm/vm_test.go @@ -240,7 +240,7 @@ func testBuildEthTxBlock(t *testing.T, scheme string) { require.Equal(common.Hash(blk1.ID()), newHead.Head.Hash()) txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { signedTx := newSignedLegacyTx(t, vm.chainConfig, vmtest.TestKeys[1].ToECDSA(), uint64(i), &vmtest.TestEthAddrs[1], big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice), nil) txs[i] = signedTx } @@ -363,7 +363,7 @@ func testSetPreferenceRace(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { signedTx := newSignedLegacyTx(t, vm1.chainConfig, vmtest.TestKeys[1].ToECDSA(), uint64(i), &vmtest.TestEthAddrs[1], big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice), nil) txs[i] = signedTx } @@ -490,7 +490,7 @@ func testReorgProtection(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { signedTx := newSignedLegacyTx(t, vm1.chainConfig, key, uint64(i), &address, big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice), nil) txs[i] = signedTx } @@ -596,7 +596,7 @@ func testNonCanonicalAccept(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { signedTx := newSignedLegacyTx(t, vm1.chainConfig, key, uint64(i), &address, big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice), nil) txs[i] = signedTx } @@ -701,7 +701,7 @@ func testStickyPreference(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { signedTx := newSignedLegacyTx(t, vm1.chainConfig, key, uint64(i), &address, big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice), nil) txs[i] = signedTx } @@ -843,7 +843,7 @@ func testUncleBlock(t *testing.T, scheme string) { require.Equal(common.Hash(vm2BlkA.ID()), newHead.Head.Hash()) txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { signedTx := newSignedLegacyTx(t, vm1.chainConfig, key, uint64(i), &address, big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice), nil) txs[i] = signedTx } @@ -946,7 +946,7 @@ func testAcceptReorg(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { signedTx = newSignedLegacyTx(t, vm1.chainConfig, key, uint64(i), &address, big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice), nil) txs[i] = signedTx } @@ -1167,7 +1167,7 @@ func testBuildApricotPhase1Block(t *testing.T, scheme string) { require.Equal(common.Hash(blk.ID()), newHead.Head.Hash()) txs := make([]*types.Transaction, 10) - for i := 0; i < 5; i++ { + for i := range 5 { signedTx := newSignedLegacyTx(t, vm.chainConfig, key, uint64(i), &address, big.NewInt(10), 21000, big.NewInt(ap0.MinGasPrice), nil) txs[i] = signedTx } @@ -1418,7 +1418,7 @@ func TestBuildBlockWithInsufficientCapacity(t *testing.T) { txs = make([]*types.Transaction, 2) err error ) - for i := uint64(0); i < 2; i++ { + for i := range uint64(2) { tx := types.NewContractCreation( i, big.NewInt(0), @@ -1487,7 +1487,7 @@ func TestBuildBlockLargeTxStarvation(t *testing.T) { // Refill capacity vm.clock.Set(vm.clock.Time().Add(acp176.TimeToFillCapacity * time.Second)) maxSizeTxs := make([]*types.Transaction, 2) - for i := uint64(0); i < 2; i++ { + for i := range uint64(2) { tx := types.NewContractCreation( i, big.NewInt(0), @@ -1774,7 +1774,7 @@ func TestCreateHandlers(t *testing.T) { defer client.Close() // Make a request at limit, ensure that all requests are handled - for i := 0; i < maxResponses; i++ { + for range maxResponses { batch = append(batch, rpc.BatchElem{ Method: "test_echo", Args: []any{"x", 1}, diff --git a/graft/coreth/plugin/evm/vm_warp_test.go b/graft/coreth/plugin/evm/vm_warp_test.go index 7e56561bbdcd..f0448dc95ac3 100644 --- a/graft/coreth/plugin/evm/vm_warp_test.go +++ b/graft/coreth/plugin/evm/vm_warp_test.go @@ -458,7 +458,7 @@ func testWarpVMTransaction(t *testing.T, scheme string, unsignedMessage *avalanc require.Len(txTraceResults, 2) blockTxTraceResultBytes, err := json.Marshal(txTraceResults[1].Result) require.NoError(err) - unmarshalResults := make(map[string]interface{}) + unmarshalResults := make(map[string]any) require.NoError(json.Unmarshal(blockTxTraceResultBytes, &unmarshalResults)) require.Empty(unmarshalResults["returnValue"]) @@ -794,7 +794,7 @@ func testReceiveWarpMessage( require.Len(txTraceResults, 1) blockTxTraceResultBytes, err := json.Marshal(txTraceResults[0].Result) require.NoError(err) - unmarshalResults := make(map[string]interface{}) + unmarshalResults := make(map[string]any) require.NoError(json.Unmarshal(blockTxTraceResultBytes, &unmarshalResults)) require.Equal(common.Bytes2Hex(expectedOutput), unmarshalResults["returnValue"]) diff --git a/graft/coreth/plugin/evm/vmtest/test_syncervm.go b/graft/coreth/plugin/evm/vmtest/test_syncervm.go index 27ba1ac90f91..3585c6edbc88 100644 --- a/graft/coreth/plugin/evm/vmtest/test_syncervm.go +++ b/graft/coreth/plugin/evm/vmtest/test_syncervm.go @@ -591,11 +591,9 @@ func testSyncerVM(t *testing.T, testSyncVMSetup *testSyncVMSetup, test SyncTestP }, func(block *types.Block) { if syncerVM.Ethereum().BlockChain().CacheConfig().TransactionHistory != 0 { - tail := block.NumberU64() - syncerVM.Ethereum().BlockChain().CacheConfig().TransactionHistory + 1 - // tail should be the minimum last synced block, since we skipped it to the last block - if tail < lastSyncedBlock.NumberU64() { - tail = lastSyncedBlock.NumberU64() - } + tail := max( + // tail should be the minimum last synced block, since we skipped it to the last block + block.NumberU64()-syncerVM.Ethereum().BlockChain().CacheConfig().TransactionHistory+1, lastSyncedBlock.NumberU64()) coretest.CheckTxIndices(t, &tail, tail, block.NumberU64(), block.NumberU64(), syncerVM.Ethereum().ChainDb(), true) } }, @@ -625,11 +623,9 @@ func testSyncerVM(t *testing.T, testSyncVMSetup *testSyncVMSetup, test SyncTestP }, func(block *types.Block) { if syncerVM.Ethereum().BlockChain().CacheConfig().TransactionHistory != 0 { - tail := block.NumberU64() - syncerVM.Ethereum().BlockChain().CacheConfig().TransactionHistory + 1 - // tail should be the minimum last synced block, since we skipped it to the last block - if tail < lastSyncedBlock.NumberU64() { - tail = lastSyncedBlock.NumberU64() - } + tail := max( + // tail should be the minimum last synced block, since we skipped it to the last block + block.NumberU64()-syncerVM.Ethereum().BlockChain().CacheConfig().TransactionHistory+1, lastSyncedBlock.NumberU64()) coretest.CheckTxIndices(t, &tail, tail, block.NumberU64(), block.NumberU64(), syncerVM.Ethereum().ChainDb(), true) } }, diff --git a/graft/coreth/plugin/evm/vmtest/test_vm.go b/graft/coreth/plugin/evm/vmtest/test_vm.go index 5c998b97e1c2..0beff1f2992f 100644 --- a/graft/coreth/plugin/evm/vmtest/test_vm.go +++ b/graft/coreth/plugin/evm/vmtest/test_vm.go @@ -115,7 +115,7 @@ func OverrideSchemeConfig(scheme string, configJSON string) (string, error) { } // Parse existing config into a map to preserve only non-zero values - configMap := make(map[string]interface{}) + configMap := make(map[string]any) if len(configJSON) > 0 { if err := json.Unmarshal([]byte(configJSON), &configMap); err != nil { return "", err diff --git a/graft/coreth/plugin/factory/factory.go b/graft/coreth/plugin/factory/factory.go index b25dae882440..d6638366c18a 100644 --- a/graft/coreth/plugin/factory/factory.go +++ b/graft/coreth/plugin/factory/factory.go @@ -22,7 +22,7 @@ var ( type Factory struct{} -func (*Factory) New(logging.Logger) (interface{}, error) { +func (*Factory) New(logging.Logger) (any, error) { return atomicvm.WrapVM(&evm.VM{}), nil } diff --git a/graft/coreth/precompile/contracts/warp/predicate_test.go b/graft/coreth/precompile/contracts/warp/predicate_test.go index a3dfa0c81a4e..a2e4949d5ccb 100644 --- a/graft/coreth/precompile/contracts/warp/predicate_test.go +++ b/graft/coreth/precompile/contracts/warp/predicate_test.go @@ -58,7 +58,7 @@ var ( func init() { testVdrs = make([]*testValidator, 0, numTestVdrs) - for i := 0; i < numTestVdrs; i++ { + for range numTestVdrs { testVdrs = append(testVdrs, newTestValidator()) } utils.Sort(testVdrs) @@ -151,7 +151,7 @@ func (g GasConfig) PredicateGasCost(chunks int, signers int) uint64 { // and the first [numKeys] signatures from [blsSignatures] func createWarpMessage(numKeys int) *avalancheWarp.Message { bitSet := set.NewBits() - for i := 0; i < numKeys; i++ { + for i := range numKeys { bitSet.Add(i) } warpSignature := &avalancheWarp.BitSetSignature{ @@ -285,7 +285,7 @@ func testWarpMessageFromPrimaryNetwork(t *testing.T, requirePrimaryNetworkSigner } blsSignatures = make([]*bls.Signature, 0, numKeys) ) - for i := 0; i < numKeys; i++ { + for i := range numKeys { vdr := testVdrs[i] sig, err := vdr.sk.Sign(unsignedMsg.Bytes()) require.NoError(err) @@ -304,7 +304,7 @@ func testWarpMessageFromPrimaryNetwork(t *testing.T, requirePrimaryNetworkSigner aggregateSignature, err := bls.AggregateSignatures(blsSignatures) require.NoError(err) bitSet := set.NewBits() - for i := 0; i < numKeys; i++ { + for i := range numKeys { bitSet.Add(i) } warpSignature := &avalancheWarp.BitSetSignature{ @@ -425,7 +425,7 @@ func TestInvalidAddressedPayload(t *testing.T) { aggregateSignature, err := bls.AggregateSignatures(blsSignatures[0:numKeys]) require.NoError(t, err) bitSet := set.NewBits() - for i := 0; i < numKeys; i++ { + for i := range numKeys { bitSet.Add(i) } warpSignature := &avalancheWarp.BitSetSignature{ @@ -777,7 +777,7 @@ func makeWarpPredicateTests(tb testing.TB, rules extras.AvalancheRules) []precom for _, totalNodes := range []int{100, 1_000, 10_000} { pred := createPredicate(numSigners) validatorSet := make(map[ids.NodeID]*validators.GetValidatorOutput, totalNodes) - for i := 0; i < totalNodes; i++ { + for i := range totalNodes { validatorSet[testVdrs[i].nodeID] = &validators.GetValidatorOutput{ NodeID: testVdrs[i].nodeID, Weight: 20, diff --git a/graft/coreth/precompile/precompiletest/test_precompile.go b/graft/coreth/precompile/precompiletest/test_precompile.go index 8763c75ac5a7..0bd86479b9bd 100644 --- a/graft/coreth/precompile/precompiletest/test_precompile.go +++ b/graft/coreth/precompile/precompiletest/test_precompile.go @@ -123,10 +123,7 @@ func (test PrecompileTest) Bench(b *testing.B, module modules.Module) { } b.StopTimer() - elapsed := uint64(time.Since(start)) - if elapsed < 1 { - elapsed = 1 - } + elapsed := max(uint64(time.Since(start)), 1) gasUsed := runParams.SuppliedGas * uint64(b.N) b.ReportMetric(float64(runParams.SuppliedGas), "gas/op") // Keep it as uint64, multiply 100 to get two digit float later diff --git a/graft/coreth/precompile/precompiletest/test_predicate.go b/graft/coreth/precompile/precompiletest/test_predicate.go index 13050fe50129..9b4a4fe1c099 100644 --- a/graft/coreth/precompile/precompiletest/test_predicate.go +++ b/graft/coreth/precompile/precompiletest/test_predicate.go @@ -63,10 +63,7 @@ func (test PredicateTest) RunBenchmark(b *testing.B) { test.Run(b) } b.StopTimer() - elapsed := uint64(time.Since(start)) - if elapsed < 1 { - elapsed = 1 - } + elapsed := max(uint64(time.Since(start)), 1) gasUsed := test.Gas * uint64(b.N) b.ReportMetric(float64(test.Gas), "gas/op") diff --git a/graft/coreth/tests/utils/proposervm.go b/graft/coreth/tests/utils/proposervm.go index 3cf6e9755e4d..67bd1bab46d3 100644 --- a/graft/coreth/tests/utils/proposervm.go +++ b/graft/coreth/tests/utils/proposervm.go @@ -45,7 +45,7 @@ func IssueTxsToActivateProposerVMFork( txSigner := types.LatestSignerForChainID(chainID) // Send exactly 2 transactions, waiting for each to be included in a block - for i := 0; i < expectedBlockHeight; i++ { + for range expectedBlockHeight { tx := types.NewTransaction( nonce, addr, common.Big1, ethparams.TxGas, gasPrice, nil) triggerTx, err := types.SignTx(tx, txSigner, fundedKey) diff --git a/graft/coreth/tests/warp/warp_test.go b/graft/coreth/tests/warp/warp_test.go index e5ddfe143cac..cfa0c80be399 100644 --- a/graft/coreth/tests/warp/warp_test.go +++ b/graft/coreth/tests/warp/warp_test.go @@ -568,7 +568,7 @@ func (w *warpTest) warpLoad() { ginkgo.GinkgoLogr.Info("Generating tx sequence to send warp messages...") warpSendSequences, err := txs.GenerateTxSequences(ctx, func(key *ecdsa.PrivateKey, nonce uint64) (*types.Transaction, error) { - data, err := warp.PackSendWarpMessage([]byte(fmt.Sprintf("Jets %d-%d Dolphins", key.X.Int64(), nonce))) + data, err := warp.PackSendWarpMessage(fmt.Appendf(nil, "Jets %d-%d Dolphins", key.X.Int64(), nonce)) if err != nil { return nil, err } diff --git a/graft/evm/sync/client/client.go b/graft/evm/sync/client/client.go index 6a308a20f6a1..90cba3ffc1c8 100644 --- a/graft/evm/sync/client/client.go +++ b/graft/evm/sync/client/client.go @@ -100,13 +100,13 @@ type Client interface { // Validates response in context of the request // Ensures the returned interface matches the expected response type of the request // Returns the number of elements in the response (specific to the response type, used in metrics) -type parseResponseFn func(codec codec.Manager, request message.Request, response []byte) (interface{}, int, error) +type parseResponseFn func(codec codec.Manager, request message.Request, response []byte) (any, int, error) type client struct { network Network codec codec.Manager stateSyncNodes []ids.NodeID - stateSyncNodeIdx uint32 + stateSyncNodeIdx atomic.Uint32 stats stats.ClientSyncerStats blockParser EthBlockParser } @@ -164,7 +164,7 @@ func (c *client) GetLeafs(ctx context.Context, req message.LeafsRequest) (messag // - first and last key in the response is not within the requested start and end range // - response keys are not in increasing order // - proof validation failed -func parseLeafsResponse(codec codec.Manager, reqIntf message.Request, data []byte) (interface{}, int, error) { +func parseLeafsResponse(codec codec.Manager, reqIntf message.Request, data []byte) (any, int, error) { var leafsResponse message.LeafsResponse if _, err := codec.Unmarshal(data, &leafsResponse); err != nil { return nil, 0, err @@ -240,7 +240,7 @@ func (c *client) GetBlocks(ctx context.Context, hash common.Hash, height uint64, // assumes req is of type message.BlockRequest // returns types.Blocks as interface{} // returns a non-nil error if the request should be retried -func (c *client) parseBlocks(codec codec.Manager, req message.Request, data []byte) (interface{}, int, error) { +func (c *client) parseBlocks(codec codec.Manager, req message.Request, data []byte) (any, int, error) { var response message.BlockResponse if _, err := codec.Unmarshal(data, &response); err != nil { return nil, 0, fmt.Errorf("%w: %w", errUnmarshalResponse, err) @@ -290,7 +290,7 @@ func (c *client) GetCode(ctx context.Context, hashes []common.Hash) ([][]byte, e // parseCode validates given object as a code object // assumes req is of type message.CodeRequest // returns a non-nil error if the request should be retried -func parseCode(codec codec.Manager, req message.Request, data []byte) (interface{}, int, error) { +func parseCode(codec codec.Manager, req message.Request, data []byte) (any, int, error) { var response message.CodeResponse if _, err := codec.Unmarshal(data, &response); err != nil { return nil, 0, err @@ -322,7 +322,7 @@ func parseCode(codec codec.Manager, req message.Request, data []byte) (interface // Retries if there is a network error or if the [parseResponseFn] returns an error indicating an invalid response. // Returns the parsed interface returned from [parseFn]. // Thread safe -func (c *client) get(ctx context.Context, request message.Request, parseFn parseResponseFn) (interface{}, error) { +func (c *client) get(ctx context.Context, request message.Request, parseFn parseResponseFn) (any, error) { // marshal the request into requestBytes requestBytes, err := message.RequestToBytes(c.codec, request) if err != nil { @@ -334,7 +334,7 @@ func (c *client) get(ctx context.Context, request message.Request, parseFn parse return nil, err } var ( - responseIntf interface{} + responseIntf any numElements int lastErr error ) @@ -361,7 +361,7 @@ func (c *client) get(ctx context.Context, request message.Request, parseFn parse } else { // get the next nodeID using the nodeIdx offset. If we're out of nodes, loop back to 0 // we do this every attempt to ensure we get a different node each time if possible. - nodeIdx := atomic.AddUint32(&c.stateSyncNodeIdx, 1) + nodeIdx := c.stateSyncNodeIdx.Add(1) nodeID = c.stateSyncNodes[nodeIdx%uint32(len(c.stateSyncNodes))] response, err = c.network.SendSyncedAppRequest(ctx, nodeID, requestBytes) diff --git a/graft/evm/sync/client/client_test.go b/graft/evm/sync/client/client_test.go index ce93acd01bad..2c0f94d73f37 100644 --- a/graft/evm/sync/client/client_test.go +++ b/graft/evm/sync/client/client_test.go @@ -8,6 +8,7 @@ import ( "context" "fmt" "math/rand" + "slices" "testing" "github.com/ava-labs/libevm/common" @@ -141,9 +142,9 @@ func TestGetBlocks(t *testing.T) { // and returns a slice of byte slices with those blocks encoded in reverse order encodeBlockSlice := func(blocks []*types.Block) [][]byte { blockBytes := make([][]byte, 0, len(blocks)) - for i := len(blocks) - 1; i >= 0; i-- { + for _, v := range slices.Backward(blocks) { buf := new(bytes.Buffer) - require.NoError(t, blocks[i].EncodeRLP(buf)) + require.NoError(t, v.EncodeRLP(buf)) blockBytes = append(blockBytes, buf.Bytes()) } diff --git a/graft/evm/sync/client/test_client.go b/graft/evm/sync/client/test_client.go index b455e40d64e5..319a604ae12c 100644 --- a/graft/evm/sync/client/test_client.go +++ b/graft/evm/sync/client/test_client.go @@ -27,11 +27,11 @@ var ( type TestClient struct { codec codec.Manager leafsHandler handlers.LeafRequestHandler - leavesReceived int32 + leavesReceived atomic.Int32 codesHandler *handlers.CodeRequestHandler - codeReceived int32 + codeReceived atomic.Int32 blocksHandler *handlers.BlockRequestHandler - blocksReceived int32 + blocksReceived atomic.Int32 // GetLeafsIntercept is called on every GetLeafs request if set to a non-nil callback. // The returned response will be returned by TestClient to the caller. GetLeafsIntercept func(req message.LeafsRequest, res message.LeafsResponse) (message.LeafsResponse, error) @@ -80,12 +80,12 @@ func (ml *TestClient) GetLeafs(ctx context.Context, request message.LeafsRequest leafsResponse, err = ml.GetLeafsIntercept(request, leafsResponse) } // Increment the number of leaves received by the test client - atomic.AddInt32(&ml.leavesReceived, int32(numLeaves)) + ml.leavesReceived.Add(int32(numLeaves)) return leafsResponse, err } func (ml *TestClient) LeavesReceived() int32 { - return atomic.LoadInt32(&ml.leavesReceived) + return ml.leavesReceived.Load() } func (ml *TestClient) GetCode(ctx context.Context, hashes []common.Hash) ([][]byte, error) { @@ -107,13 +107,13 @@ func (ml *TestClient) GetCode(ctx context.Context, hashes []common.Hash) ([][]by code, err = ml.GetCodeIntercept(hashes, code) } if err == nil { - atomic.AddInt32(&ml.codeReceived, int32(lenCode)) + ml.codeReceived.Add(int32(lenCode)) } return code, err } func (ml *TestClient) CodeReceived() int32 { - return atomic.LoadInt32(&ml.codeReceived) + return ml.codeReceived.Load() } func (ml *TestClient) GetBlocks(ctx context.Context, blockHash common.Hash, height uint64, numParents uint16) ([]*types.Block, error) { @@ -144,12 +144,12 @@ func (ml *TestClient) GetBlocks(ctx context.Context, blockHash common.Hash, heig if ml.GetBlocksIntercept != nil { blocks, err = ml.GetBlocksIntercept(request, blocks) } - atomic.AddInt32(&ml.blocksReceived, int32(numBlocks)) + ml.blocksReceived.Add(int32(numBlocks)) return blocks, err } func (ml *TestClient) BlocksReceived() int32 { - return atomic.LoadInt32(&ml.blocksReceived) + return ml.blocksReceived.Load() } type testBlockParser struct{} diff --git a/graft/evm/sync/client/test_network.go b/graft/evm/sync/client/test_network.go index 4e0cff219df8..9a41ac72d42e 100644 --- a/graft/evm/sync/client/test_network.go +++ b/graft/evm/sync/client/test_network.go @@ -77,7 +77,7 @@ func (t *testNetwork) processTest() ([]byte, error) { func (t *testNetwork) testResponse(times uint8, callback func(), response []byte) { t.response = make([][]byte, times) - for i := uint8(0); i < times; i++ { + for i := range times { t.response[i] = response } t.callback = callback diff --git a/graft/evm/sync/code/syncer_test.go b/graft/evm/sync/code/syncer_test.go index 822e180c7893..49d0b5ba0006 100644 --- a/graft/evm/sync/code/syncer_test.go +++ b/graft/evm/sync/code/syncer_test.go @@ -113,7 +113,7 @@ func TestCodeSyncerManyCodeHashes(t *testing.T) { numCodeSlices := 5000 codeHashes := make([]common.Hash, 0, numCodeSlices) codeByteSlices := make([][]byte, 0, numCodeSlices) - for i := 0; i < numCodeSlices; i++ { + for range numCodeSlices { codeBytes := utils.RandomBytes(100) codeHash := crypto.Keccak256Hash(codeBytes) codeHashes = append(codeHashes, codeHash) @@ -166,7 +166,7 @@ func TestCodeSyncerAddsMoreInProgressThanQueueSize(t *testing.T) { numCodeSlices := 100 codeHashes := make([]common.Hash, 0, numCodeSlices) codeByteSlices := make([][]byte, 0, numCodeSlices) - for i := 0; i < numCodeSlices; i++ { + for range numCodeSlices { codeBytes := utils.RandomBytes(100) codeHash := crypto.Keccak256Hash(codeBytes) codeHashes = append(codeHashes, codeHash) diff --git a/graft/evm/sync/engine/client.go b/graft/evm/sync/engine/client.go index 28c0724f58d0..b01a5273493d 100644 --- a/graft/evm/sync/engine/client.go +++ b/graft/evm/sync/engine/client.go @@ -264,9 +264,7 @@ func (c *client) startAsync(executor Executor, summary message.Syncable) block.S ctx, cancel := context.WithCancel(context.Background()) c.cancel = cancel - c.wg.Add(1) - go func() { - defer c.wg.Done() + c.wg.Go(func() { defer cancel() if err := executor.Execute(ctx, summary); err != nil { @@ -277,7 +275,7 @@ func (c *client) startAsync(executor Executor, summary message.Syncable) block.S // vm.SetState(snow.Bootstrapping) log.Info("state sync completed, notifying engine", "err", c.err) close(c.config.StateSyncDone) - }() + }) log.Info("state sync started", "mode", block.StateSyncStatic) return block.StateSyncStatic diff --git a/graft/evm/sync/engine/registry_test.go b/graft/evm/sync/engine/registry_test.go index f56ef210c42b..1acb59d6b63b 100644 --- a/graft/evm/sync/engine/registry_test.go +++ b/graft/evm/sync/engine/registry_test.go @@ -197,7 +197,7 @@ func TestSyncerRegistry_ConcurrentStart(t *testing.T) { releaseCh := make(chan struct{}) - for i := 0; i < numBarrierSyncers; i++ { + for i := range numBarrierSyncers { name := fmt.Sprintf("BarrierSyncer-%d", i) require.NoError(t, registry.Register(NewBarrierSyncer(name, &allStartedWG, releaseCh))) } @@ -263,7 +263,7 @@ func TestSyncerRegistry_FirstErrorWinsAcrossMany(t *testing.T) { ) allErrorSyncersStartedWG.Add(numErrorSyncers) - for i := 0; i < numErrorSyncers; i++ { + for i := range numErrorSyncers { trigger := make(chan struct{}) triggers = append(triggers, trigger) errInstance := errors.New("boom") @@ -373,7 +373,7 @@ func TestSyncerRegistry_EarlyReturnOnAlreadyCancelledContext(t *testing.T) { // Register syncers (they should never start). const numSyncers = 2 mockSyncers := make([]*mockSyncer, numSyncers) - for i := 0; i < numSyncers; i++ { + for i := range numSyncers { name := fmt.Sprintf("Syncer-%d", i) mockSyncer := newMockSyncer(name, nil) mockSyncers[i] = mockSyncer @@ -443,7 +443,7 @@ func registerCancelAwareSyncers(t *testing.T, registry *SyncerRegistry, numSynce t.Helper() var startedWG sync.WaitGroup startedWG.Add(numSyncers) - for i := 0; i < numSyncers; i++ { + for i := range numSyncers { name := fmt.Sprintf("Syncer-%d", i) require.NoError(t, registry.Register(NewCancelAwareSyncer(name, &startedWG, timeout))) } diff --git a/graft/evm/sync/evmstate/trie_segments.go b/graft/evm/sync/evmstate/trie_segments.go index b7b06e63fe02..ccd9a56344ed 100644 --- a/graft/evm/sync/evmstate/trie_segments.go +++ b/graft/evm/sync/evmstate/trie_segments.go @@ -285,7 +285,7 @@ func (t *trieToSync) createSegments(ctx context.Context, numSegments int) error segmentStep := 0x10000 / numSegments - for i := 0; i < numSegments; i++ { + for i := range numSegments { start := uint16(i * segmentStep) end := uint16(i*segmentStep + (segmentStep - 1)) diff --git a/graft/evm/sync/handlers/block_request.go b/graft/evm/sync/handlers/block_request.go index a034e3293bcb..0d48f9c52f26 100644 --- a/graft/evm/sync/handlers/block_request.go +++ b/graft/evm/sync/handlers/block_request.go @@ -63,10 +63,7 @@ func (b *BlockRequestHandler) OnBlockRequest(ctx context.Context, nodeID ids.Nod b.stats.IncBlockRequest() // override given Parents limit if it is greater than parentLimit - parents := blockRequest.Parents - if parents > parentLimit { - parents = parentLimit - } + parents := min(blockRequest.Parents, parentLimit) blocks := make([][]byte, 0, parents) totalBytes := 0 diff --git a/graft/evm/sync/handlers/leafs_request.go b/graft/evm/sync/handlers/leafs_request.go index 66101f6af144..de6ead2c1329 100644 --- a/graft/evm/sync/handlers/leafs_request.go +++ b/graft/evm/sync/handlers/leafs_request.go @@ -114,10 +114,7 @@ func (lrh *leafsRequestHandler) OnLeafsRequest(ctx context.Context, nodeID ids.N return nil, nil } // override limit if it is greater than the configured maxLeavesLimit - limit := leafsRequest.KeyLimit() - if limit > maxLeavesLimit { - limit = maxLeavesLimit - } + limit := min(leafsRequest.KeyLimit(), maxLeavesLimit) var leafsResponse message.LeafsResponse leafsResponse.Keys = make([][]byte, 0, limit) diff --git a/graft/evm/sync/synctest/trie.go b/graft/evm/sync/synctest/trie.go index afbe86f2cd28..050166dac6d2 100644 --- a/graft/evm/sync/synctest/trie.go +++ b/graft/evm/sync/synctest/trie.go @@ -36,7 +36,7 @@ func FillAccountsWithOverlappingStorage( t *testing.T, r *rand.Rand, s state.Database, root common.Hash, numAccounts int, numOverlappingStorageRoots int, ) (common.Hash, map[*utilstest.Key]*types.StateAccount) { storageRoots := make([]common.Hash, 0, numOverlappingStorageRoots) - for i := 0; i < numOverlappingStorageRoots; i++ { + for range numOverlappingStorageRoots { storageRoot, _, _ := GenerateIndependentTrie(t, r, s.TrieDB(), 16, common.HashLength) storageRoots = append(storageRoots, storageRoot) } @@ -174,7 +174,7 @@ func FillAccounts( tr, err := s.OpenTrie(root) require.NoError(t, err) - for i := 0; i < numAccounts; i++ { + for i := range numAccounts { key := utilstest.NewKey(t) acc := types.StateAccount{ Nonce: uint64(r.Intn(maxNonce)), diff --git a/graft/evm/utils/bounded_workers.go b/graft/evm/utils/bounded_workers.go index 882eecc1d60c..c17c27908ec0 100644 --- a/graft/evm/utils/bounded_workers.go +++ b/graft/evm/utils/bounded_workers.go @@ -30,18 +30,15 @@ func NewBoundedWorkers(count int) *BoundedWorkers { // alive to continue executing new work. func (b *BoundedWorkers) startWorker(f func()) { b.workerCount.Add(1) - b.outstandingWorkers.Add(1) - - go func() { - defer b.outstandingWorkers.Done() + b.outstandingWorkers.Go(func() { if f != nil { f() } for f := range b.work { f() } - }() + }) } // Execute the given function on an existing goroutine waiting for more work, a new goroutine, diff --git a/graft/evm/utils/bytes_test.go b/graft/evm/utils/bytes_test.go index 196beb755c8d..b7f28be8ce7f 100644 --- a/graft/evm/utils/bytes_test.go +++ b/graft/evm/utils/bytes_test.go @@ -56,7 +56,7 @@ func testBytesToHashSlice(t testing.TB, b []byte) { } func FuzzHashSliceToBytes(f *testing.F) { - for i := 0; i < 100; i++ { + for i := range 100 { f.Add(utils.RandomBytes(i)) } diff --git a/graft/evm/utils/metered_cache.go b/graft/evm/utils/metered_cache.go index 8eef8a2937eb..2a5b975080d0 100644 --- a/graft/evm/utils/metered_cache.go +++ b/graft/evm/utils/metered_cache.go @@ -26,7 +26,7 @@ type MeteredCache struct { statsTime metrics.Gauge // count all operations to decide when to update stats - ops uint64 + ops atomic.Uint64 updateFrequency uint64 } @@ -60,7 +60,7 @@ func (mc *MeteredCache) updateStatsIfNeeded() { if mc.namespace == "" { return } - ops := atomic.AddUint64(&mc.ops, 1) + ops := mc.ops.Add(1) if ops%mc.updateFrequency != 0 { return } diff --git a/graft/evm/utils/rpc/handler.go b/graft/evm/utils/rpc/handler.go index c8051c2cb6fc..7808c6cbe2f1 100644 --- a/graft/evm/utils/rpc/handler.go +++ b/graft/evm/utils/rpc/handler.go @@ -15,7 +15,7 @@ import ( // - The handler's functionality is defined by [service] // [service] should be a gorilla RPC service (see https://www.gorillatoolkit.org/pkg/rpc/v2) // - The name of the service is [name] -func NewHandler(name string, service interface{}) (http.Handler, error) { +func NewHandler(name string, service any) (http.Handler, error) { server := rpc.NewServer() server.RegisterCodec(json.NewCodec(), "application/json") server.RegisterCodec(json.NewCodec(), "application/json;charset=UTF-8") diff --git a/graft/subnet-evm/cmd/simulator/txs/tx_generator.go b/graft/subnet-evm/cmd/simulator/txs/tx_generator.go index 0aa25f54552e..ef1e2cdaa2cd 100644 --- a/graft/subnet-evm/cmd/simulator/txs/tx_generator.go +++ b/graft/subnet-evm/cmd/simulator/txs/tx_generator.go @@ -60,7 +60,7 @@ func addTxs(ctx context.Context, txSequence *txSequence, generator CreateTx, cli if err != nil { return err } - for i := uint64(0); i < numTxs; i++ { + for i := range numTxs { tx, err := generator(key, startingNonce+i) if err != nil { return err diff --git a/graft/subnet-evm/core/blockchain_ext_test.go b/graft/subnet-evm/core/blockchain_ext_test.go index 95504639bec3..7a908cf0994c 100644 --- a/graft/subnet-evm/core/blockchain_ext_test.go +++ b/graft/subnet-evm/core/blockchain_ext_test.go @@ -330,7 +330,7 @@ func InsertLongForkedChain(t *testing.T, create createFunc) { require.Equal(len(chain1)+len(chain2), blockchain.snaps.NumBlockLayers(), "incorrect snapshot layer count") } - for i := 0; i < len(chain2); i++ { + for i := range chain2 { require.NoError(blockchain.Reject(chain2[i])) if blockchain.snaps != nil { @@ -438,7 +438,7 @@ func AcceptNonCanonicalBlock(t *testing.T, create createFunc) { require.NoError(blockchain.Accept(chain2[0])) blockchain.DrainAcceptorQueue() - for i := 0; i < len(chain1); i++ { + for i := range chain1 { require.NoError(blockchain.Reject(chain1[i])) require.False(blockchain.HasBlock(chain1[i].Hash(), chain1[i].NumberU64())) } diff --git a/graft/subnet-evm/core/state_manager_test.go b/graft/subnet-evm/core/state_manager_test.go index 395666cafda3..35c75361a866 100644 --- a/graft/subnet-evm/core/state_manager_test.go +++ b/graft/subnet-evm/core/state_manager_test.go @@ -80,7 +80,7 @@ func TestCappedMemoryTrieWriter(t *testing.T) { func TestNoPruningTrieWriter(t *testing.T) { m := &MockTrieDB{} w := NewTrieWriter(m, &CacheConfig{}) - for i := 0; i < tipBufferSize+1; i++ { + for i := range tipBufferSize + 1 { bigI := big.NewInt(int64(i)) block := types.NewBlock( &types.Header{ diff --git a/graft/subnet-evm/core/state_processor_ext.go b/graft/subnet-evm/core/state_processor_ext.go index b4d2c58ab93c..94a42599b8fe 100644 --- a/graft/subnet-evm/core/state_processor_ext.go +++ b/graft/subnet-evm/core/state_processor_ext.go @@ -45,7 +45,7 @@ func ApplyPrecompileActivations(c *params.ChainConfig, parentTimestamp *uint64, statedb.Finalise(true) continue } - var printIntf interface{} + var printIntf any marshalled, err := json.Marshal(activatingConfig) if err == nil { printIntf = string(marshalled) diff --git a/graft/subnet-evm/eth/gasprice/fee_info_provider_test.go b/graft/subnet-evm/eth/gasprice/fee_info_provider_test.go index 3a018af18940..727893657287 100644 --- a/graft/subnet-evm/eth/gasprice/fee_info_provider_test.go +++ b/graft/subnet-evm/eth/gasprice/fee_info_provider_test.go @@ -56,7 +56,7 @@ func TestFeeInfoProviderCacheSize(t *testing.T) { } // these numbers should be evicted - for i := 0; i < overflow; i++ { + for i := range overflow { feeInfo, ok := f.get(uint64(i)) require.False(t, ok) require.Nil(t, feeInfo) diff --git a/graft/subnet-evm/internal/ethapi/api_extra.go b/graft/subnet-evm/internal/ethapi/api_extra.go index c8b0b47f30d6..8d36eb775998 100644 --- a/graft/subnet-evm/internal/ethapi/api_extra.go +++ b/graft/subnet-evm/internal/ethapi/api_extra.go @@ -64,10 +64,10 @@ func (s *BlockChainAPI) CallDetailed(ctx context.Context, args TransactionArgs, // // BadBlockArgs represents the entries in the list returned when bad blocks are queried. type BadBlockArgs struct { - Hash common.Hash `json:"hash"` - Block map[string]interface{} `json:"block"` - RLP string `json:"rlp"` - Reason *core.BadBlockReason `json:"reason"` + Hash common.Hash `json:"hash"` + Block map[string]any `json:"block"` + RLP string `json:"rlp"` + Reason *core.BadBlockReason `json:"reason"` } // GetBadBlocks returns a list of the last 'bad blocks' that the client has seen on the network @@ -80,7 +80,7 @@ func (s *BlockChainAPI) GetBadBlocks(context.Context) ([]*BadBlockArgs, error) { for i, block := range badBlocks { var ( blockRlp string - blockJSON map[string]interface{} + blockJSON map[string]any ) if rlpBytes, err := rlp.EncodeToBytes(block); err != nil { blockRlp = err.Error() // Hacky, but hey, it works diff --git a/graft/subnet-evm/network/network_test.go b/graft/subnet-evm/network/network_test.go index 3a69d1781d47..daba5f5b4c9c 100644 --- a/graft/subnet-evm/network/network_test.go +++ b/graft/subnet-evm/network/network_test.go @@ -247,13 +247,11 @@ func TestAppRequestOnShutdown(t *testing.T) { ) sender := testAppSender{ sendAppRequestFn: func(context.Context, set.Set[ids.NodeID], uint32, []byte) error { - wg.Add(1) - go func() { + wg.Go(func() { called = true // shutdown the network here to ensure any outstanding requests are handled as failed net.Shutdown() - wg.Done() - }() // this is on a goroutine to avoid a deadlock since calling Shutdown takes the lock. + }) // this is on a goroutine to avoid a deadlock since calling Shutdown takes the lock. return nil }, } @@ -598,7 +596,7 @@ func TestNetworkRouting(t *testing.T) { require.ErrorIs(err, p2p.ErrUnrequestedResponse) } -func buildCodec(t *testing.T, types ...interface{}) codec.Manager { +func buildCodec(t *testing.T, types ...any) codec.Manager { codecManager := codec.NewDefaultManager() c := linearcodec.NewDefault() for _, typ := range types { @@ -610,7 +608,7 @@ func buildCodec(t *testing.T, types ...interface{}) codec.Manager { // marshalStruct is a helper method used to marshal an object as `interface{}` // so that the codec is able to include the TypeID in the resulting bytes -func marshalStruct(codec codec.Manager, obj interface{}) ([]byte, error) { +func marshalStruct(codec codec.Manager, obj any) ([]byte, error) { return codec.Marshal(message.Version, &obj) } diff --git a/graft/subnet-evm/network/peer_tracker_test.go b/graft/subnet-evm/network/peer_tracker_test.go index aa6061c55d5e..1e938da9b6e2 100644 --- a/graft/subnet-evm/network/peer_tracker_test.go +++ b/graft/subnet-evm/network/peer_tracker_test.go @@ -55,7 +55,7 @@ func TestPeerTracker(t *testing.T) { // Expect requests to go to responsive or new peers, so long as they are available numRequests := 50 - for i := 0; i < numRequests; i++ { + for i := range numRequests { peer, ok, err := p.GetAnyPeer(nil) require.NoError(err) require.True(ok) diff --git a/graft/subnet-evm/params/config_extra.go b/graft/subnet-evm/params/config_extra.go index 0c4ebb08f497..b53bc0094f73 100644 --- a/graft/subnet-evm/params/config_extra.go +++ b/graft/subnet-evm/params/config_extra.go @@ -105,7 +105,7 @@ func WithExtra(c *ChainConfig, extra *extras.ChainConfig) *ChainConfig { type ChainConfigWithUpgradesJSON struct { ChainConfig - UpgradeConfig extras.UpgradeConfig `json:"upgrades,omitempty"` + UpgradeConfig extras.UpgradeConfig `json:"upgrades"` } // MarshalJSON implements json.Marshaler. This is a workaround for the fact that diff --git a/graft/subnet-evm/plugin/evm/config/config.go b/graft/subnet-evm/plugin/evm/config/config.go index 2ddfbdc27ba8..727e950d24bd 100644 --- a/graft/subnet-evm/plugin/evm/config/config.go +++ b/graft/subnet-evm/plugin/evm/config/config.go @@ -217,7 +217,7 @@ func (c Config) EthAPIs() []string { } func (d *Duration) UnmarshalJSON(data []byte) (err error) { - var v interface{} + var v any if err := json.Unmarshal(data, &v); err != nil { return err } diff --git a/graft/subnet-evm/plugin/evm/config/config_test.go b/graft/subnet-evm/plugin/evm/config/config_test.go index c155c652bd6f..4ba3f647541a 100644 --- a/graft/subnet-evm/plugin/evm/config/config_test.go +++ b/graft/subnet-evm/plugin/evm/config/config_test.go @@ -30,7 +30,7 @@ func TestUnmarshalConfig(t *testing.T) { }, { "integer durations parsed", - []byte(fmt.Sprintf(`{"api-max-duration": "%v", "continuous-profiler-frequency": "%v"}`, 1*time.Minute, 2*time.Minute)), + fmt.Appendf(nil, `{"api-max-duration": "%v", "continuous-profiler-frequency": "%v"}`, 1*time.Minute, 2*time.Minute), Config{APIMaxDuration: Duration{1 * time.Minute}, ContinuousProfilerFrequency: Duration{2 * time.Minute}}, false, }, diff --git a/graft/subnet-evm/plugin/evm/factory.go b/graft/subnet-evm/plugin/evm/factory.go index 10580ee57142..9c3bb6a1236d 100644 --- a/graft/subnet-evm/plugin/evm/factory.go +++ b/graft/subnet-evm/plugin/evm/factory.go @@ -19,6 +19,6 @@ var ( type Factory struct{} -func (*Factory) New(logging.Logger) (interface{}, error) { +func (*Factory) New(logging.Logger) (any, error) { return &VM{}, nil } diff --git a/graft/subnet-evm/plugin/evm/gossip_test.go b/graft/subnet-evm/plugin/evm/gossip_test.go index ccd9b5e5567d..f78202d5403c 100644 --- a/graft/subnet-evm/plugin/evm/gossip_test.go +++ b/graft/subnet-evm/plugin/evm/gossip_test.go @@ -117,7 +117,7 @@ func getValidEthTxs(key *ecdsa.PrivateKey, count int, gasPrice *big.Int) []*type amount := big.NewInt(0) gasLimit := uint64(37000) - for i := 0; i < count; i++ { + for i := range count { tx, _ := types.SignTx( types.NewTransaction( uint64(i), diff --git a/graft/subnet-evm/plugin/evm/health.go b/graft/subnet-evm/plugin/evm/health.go index 434772669e25..8fed12cf0308 100644 --- a/graft/subnet-evm/plugin/evm/health.go +++ b/graft/subnet-evm/plugin/evm/health.go @@ -8,7 +8,7 @@ import "context" // Health returns nil if this chain is healthy. // Also returns details, which should be one of: // string, []byte, map[string]string -func (*VM) HealthCheck(context.Context) (interface{}, error) { +func (*VM) HealthCheck(context.Context) (any, error) { // TODO perform actual health check return nil, nil } diff --git a/graft/subnet-evm/plugin/evm/status.go b/graft/subnet-evm/plugin/evm/status.go index c9b057ffe1ae..f985c12b52b7 100644 --- a/graft/subnet-evm/plugin/evm/status.go +++ b/graft/subnet-evm/plugin/evm/status.go @@ -30,7 +30,7 @@ func (s Status) MarshalJSON() ([]byte, error) { if err := s.Valid(); err != nil { return nil, err } - return []byte(fmt.Sprintf("%q", s)), nil + return fmt.Appendf(nil, "%q", s), nil } // UnmarshalJSON ... diff --git a/graft/subnet-evm/plugin/evm/syncervm_test.go b/graft/subnet-evm/plugin/evm/syncervm_test.go index e532b08b0b59..5239656d58f1 100644 --- a/graft/subnet-evm/plugin/evm/syncervm_test.go +++ b/graft/subnet-evm/plugin/evm/syncervm_test.go @@ -515,11 +515,9 @@ func testSyncerVM(t *testing.T, vmSetup *syncVMSetup, test syncTest) { }, func(block *types.Block) { if syncerVM.ethConfig.TransactionHistory != 0 { - tail := block.NumberU64() - syncerVM.ethConfig.TransactionHistory + 1 - // tail should be the minimum last synced block, since we skipped it to the last block - if tail < lastSyncedBlock.NumberU64() { - tail = lastSyncedBlock.NumberU64() - } + tail := max( + // tail should be the minimum last synced block, since we skipped it to the last block + block.NumberU64()-syncerVM.ethConfig.TransactionHistory+1, lastSyncedBlock.NumberU64()) coretest.CheckTxIndices(t, &tail, tail, block.NumberU64(), block.NumberU64(), syncerVM.chaindb, true) } }, @@ -549,11 +547,9 @@ func testSyncerVM(t *testing.T, vmSetup *syncVMSetup, test syncTest) { }, func(block *types.Block) { if syncerVM.ethConfig.TransactionHistory != 0 { - tail := block.NumberU64() - syncerVM.ethConfig.TransactionHistory + 1 - // tail should be the minimum last synced block, since we skipped it to the last block - if tail < lastSyncedBlock.NumberU64() { - tail = lastSyncedBlock.NumberU64() - } + tail := max( + // tail should be the minimum last synced block, since we skipped it to the last block + block.NumberU64()-syncerVM.ethConfig.TransactionHistory+1, lastSyncedBlock.NumberU64()) coretest.CheckTxIndices(t, &tail, tail, block.NumberU64(), block.NumberU64(), syncerVM.chaindb, true) } }, diff --git a/graft/subnet-evm/plugin/evm/vm.go b/graft/subnet-evm/plugin/evm/vm.go index 0f454c5012e2..35f4718c556b 100644 --- a/graft/subnet-evm/plugin/evm/vm.go +++ b/graft/subnet-evm/plugin/evm/vm.go @@ -828,9 +828,7 @@ func (vm *VM) onNormalOperationsStarted() error { return err } - vm.shutdownWg.Add(1) - go func() { - defer vm.shutdownWg.Done() + vm.shutdownWg.Go(func() { ticker := time.NewTicker(syncFrequency) defer ticker.Stop() @@ -844,17 +842,15 @@ func (vm *VM) onNormalOperationsStarted() error { } } } - }() + }) ethTxPool, err := NewGossipEthTxPool(vm.txPool, vm.sdkMetrics) if err != nil { return fmt.Errorf("failed to initialize gossip eth tx pool: %w", err) } - vm.shutdownWg.Add(1) - go func() { + vm.shutdownWg.Go(func() { ethTxPool.Subscribe(ctx) - vm.shutdownWg.Done() - }() + }) handler, pullGossiper, pushGossiper, err := avalanchegossip.NewSystem( vm.ctx.NodeID, @@ -905,16 +901,12 @@ func (vm *VM) onNormalOperationsStarted() error { vm.ethTxPullGossiper = pullGossiper } - vm.shutdownWg.Add(1) - go func() { + vm.shutdownWg.Go(func() { avalanchegossip.Every(ctx, vm.ctx.Log, ethTxPushGossiper, vm.config.PushGossipFrequency.Duration) - vm.shutdownWg.Done() - }() - vm.shutdownWg.Add(1) - go func() { + }) + vm.shutdownWg.Go(func() { avalanchegossip.Every(ctx, vm.ctx.Log, vm.ethTxPullGossiper, vm.config.PullGossipFrequency.Duration) - vm.shutdownWg.Done() - }() + }) return nil } @@ -1138,7 +1130,7 @@ func (*VM) Version(context.Context) (string, error) { // - The handler's functionality is defined by [service] // [service] should be a gorilla RPC service (see https://www.gorillatoolkit.org/pkg/rpc/v2) // - The name of the service is [name] -func newHandler(name string, service interface{}) (http.Handler, error) { +func newHandler(name string, service any) (http.Handler, error) { server := avalancheRPC.NewServer() server.RegisterCodec(avajson.NewCodec(), "application/json") server.RegisterCodec(avajson.NewCodec(), "application/json;charset=UTF-8") @@ -1247,15 +1239,13 @@ func (vm *VM) startContinuousProfiler() { ) defer vm.profiler.Shutdown() - vm.shutdownWg.Add(1) - go func() { - defer vm.shutdownWg.Done() + vm.shutdownWg.Go(func() { log.Info("Dispatching continuous profiler", "dir", vm.config.ContinuousProfilerDir, "freq", vm.config.ContinuousProfilerFrequency, "maxFiles", vm.config.ContinuousProfilerMaxFiles) err := vm.profiler.Dispatch() if err != nil { log.Error("continuous profiler failed", "err", err) } - }() + }) // Wait for shutdownChan to be closed <-vm.shutdownChan } diff --git a/graft/subnet-evm/plugin/evm/vm_test.go b/graft/subnet-evm/plugin/evm/vm_test.go index d20744dc7b28..eafd28574cec 100644 --- a/graft/subnet-evm/plugin/evm/vm_test.go +++ b/graft/subnet-evm/plugin/evm/vm_test.go @@ -393,7 +393,7 @@ func testBuildEthTxBlock(t *testing.T, scheme string) { require.Equal(t, common.Hash(blk1.ID()), newHead.Head.Hash(), "Expected new block to match") txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { tx := types.NewTransaction(uint64(i), key.Address, big.NewInt(10), 21000, big.NewInt(testMinGasPrice), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(tvm.vm.chainConfig.ChainID), key.PrivateKey) require.NoError(t, err) @@ -535,7 +535,7 @@ func testSetPreferenceRace(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { tx := types.NewTransaction(uint64(i), testEthAddrs[0], big.NewInt(10), 21000, big.NewInt(testMinGasPrice), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(vm1.chainConfig.ChainID), testKeys[1].ToECDSA()) require.NoError(t, err) @@ -713,7 +713,7 @@ func testReorgProtection(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { tx := types.NewTransaction(uint64(i), testEthAddrs[0], big.NewInt(10), 21000, big.NewInt(testMinGasPrice), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(vm1.chainConfig.ChainID), testKeys[1].ToECDSA()) require.NoError(t, err) @@ -858,7 +858,7 @@ func testNonCanonicalAccept(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { tx := types.NewTransaction(uint64(i), testEthAddrs[0], big.NewInt(10), 21000, big.NewInt(testMinGasPrice), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(vm1.chainConfig.ChainID), testKeys[1].ToECDSA()) require.NoError(t, err) @@ -996,7 +996,7 @@ func testStickyPreference(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { tx := types.NewTransaction(uint64(i), testEthAddrs[0], big.NewInt(10), 21000, big.NewInt(testMinGasPrice), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(vm1.chainConfig.ChainID), testKeys[1].ToECDSA()) require.NoError(t, err) @@ -1174,7 +1174,7 @@ func testUncleBlock(t *testing.T, scheme string) { require.Equal(t, common.Hash(vm2BlkA.ID()), newHead.Head.Hash(), "Expected new block to match") txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { tx := types.NewTransaction(uint64(i), testEthAddrs[0], big.NewInt(10), 21000, big.NewInt(testMinGasPrice), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(vm1.chainConfig.ChainID), testKeys[1].ToECDSA()) require.NoError(t, err) @@ -1383,7 +1383,7 @@ func testAcceptReorg(t *testing.T, scheme string) { // Create list of 10 successive transactions to build block A on vm1 // and to be split into two separate blocks on VM2 txs := make([]*types.Transaction, 10) - for i := 0; i < 10; i++ { + for i := range 10 { tx := types.NewTransaction(uint64(i), testEthAddrs[0], big.NewInt(10), 21000, big.NewInt(testMinGasPrice), nil) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(vm1.chainConfig.ChainID), testKeys[1].ToECDSA()) require.NoError(t, err) @@ -3182,7 +3182,7 @@ func TestCreateHandlers(t *testing.T) { defer client.Close() // Make a request at limit, ensure that all requests are handled - for i := 0; i < maxResponses; i++ { + for range maxResponses { batch = append(batch, rpc.BatchElem{ Method: "test_echo", Args: []any{"x", 1}, diff --git a/graft/subnet-evm/plugin/evm/vm_upgrade_bytes_test.go b/graft/subnet-evm/plugin/evm/vm_upgrade_bytes_test.go index 5b7919770dff..784d8a78aca9 100644 --- a/graft/subnet-evm/plugin/evm/vm_upgrade_bytes_test.go +++ b/graft/subnet-evm/plugin/evm/vm_upgrade_bytes_test.go @@ -215,7 +215,7 @@ func TestNetworkUpgradesOverridden(t *testing.T) { require.ErrorContains(t, err, "mismatching Granite fork block timestamp") //nolint:forbidigo // uses upstream code } -func mustMarshal(t *testing.T, v interface{}) string { +func mustMarshal(t *testing.T, v any) string { b, err := json.Marshal(v) require.NoError(t, err) return string(b) diff --git a/graft/subnet-evm/plugin/evm/vm_warp_test.go b/graft/subnet-evm/plugin/evm/vm_warp_test.go index b1a6d9abdf4b..832cc7706db2 100644 --- a/graft/subnet-evm/plugin/evm/vm_warp_test.go +++ b/graft/subnet-evm/plugin/evm/vm_warp_test.go @@ -482,7 +482,7 @@ func testWarpVMTransaction(t *testing.T, scheme string, unsignedMessage *avalanc require.Len(txTraceResults, 2) blockTxTraceResultBytes, err := json.Marshal(txTraceResults[1].Result) require.NoError(err) - unmarshalResults := make(map[string]interface{}) + unmarshalResults := make(map[string]any) require.NoError(json.Unmarshal(blockTxTraceResultBytes, &unmarshalResults)) require.Empty(unmarshalResults["returnValue"]) @@ -815,7 +815,7 @@ func testReceiveWarpMessage( require.Len(txTraceResults, 1) blockTxTraceResultBytes, err := json.Marshal(txTraceResults[0].Result) require.NoError(err) - unmarshalResults := make(map[string]interface{}) + unmarshalResults := make(map[string]any) require.NoError(json.Unmarshal(blockTxTraceResultBytes, &unmarshalResults)) require.Equal(common.Bytes2Hex(expectedOutput), unmarshalResults["returnValue"]) diff --git a/graft/subnet-evm/precompile/contracts/warp/predicate_test.go b/graft/subnet-evm/precompile/contracts/warp/predicate_test.go index acfea680d32b..0c57fadc08bb 100644 --- a/graft/subnet-evm/precompile/contracts/warp/predicate_test.go +++ b/graft/subnet-evm/precompile/contracts/warp/predicate_test.go @@ -59,7 +59,7 @@ var ( func init() { testVdrs = make([]*testValidator, 0, numTestVdrs) - for i := 0; i < numTestVdrs; i++ { + for range numTestVdrs { testVdrs = append(testVdrs, newTestValidator()) } utils.Sort(testVdrs) @@ -152,7 +152,7 @@ func (g GasConfig) PredicateGasCost(chunks int, signers int) uint64 { // and the first [numKeys] signatures from [blsSignatures] func createWarpMessage(numKeys int) *avalancheWarp.Message { bitSet := set.NewBits() - for i := 0; i < numKeys; i++ { + for i := range numKeys { bitSet.Add(i) } warpSignature := &avalancheWarp.BitSetSignature{ @@ -287,7 +287,7 @@ func testWarpMessageFromPrimaryNetwork(t *testing.T, requirePrimaryNetworkSigner } blsSignatures = make([]*bls.Signature, 0, numKeys) ) - for i := 0; i < numKeys; i++ { + for i := range numKeys { vdr := testVdrs[i] sig, err := vdr.sk.Sign(unsignedMsg.Bytes()) require.NoError(err) @@ -306,7 +306,7 @@ func testWarpMessageFromPrimaryNetwork(t *testing.T, requirePrimaryNetworkSigner aggregateSignature, err := bls.AggregateSignatures(blsSignatures) require.NoError(err) bitSet := set.NewBits() - for i := 0; i < numKeys; i++ { + for i := range numKeys { bitSet.Add(i) } warpSignature := &avalancheWarp.BitSetSignature{ @@ -428,7 +428,7 @@ func TestInvalidAddressedPayload(t *testing.T) { aggregateSignature, err := bls.AggregateSignatures(blsSignatures[0:numKeys]) require.NoError(t, err) bitSet := set.NewBits() - for i := 0; i < numKeys; i++ { + for i := range numKeys { bitSet.Add(i) } warpSignature := &avalancheWarp.BitSetSignature{ @@ -780,7 +780,7 @@ func makeWarpPredicateTests(tb testing.TB, rules extras.AvalancheRules) []precom for _, totalNodes := range []int{100, 1_000, 10_000} { pred := createPredicate(numSigners) validatorSet := make(map[ids.NodeID]*validators.GetValidatorOutput, totalNodes) - for i := 0; i < totalNodes; i++ { + for i := range totalNodes { validatorSet[testVdrs[i].nodeID] = &validators.GetValidatorOutput{ NodeID: testVdrs[i].nodeID, Weight: 20, diff --git a/graft/subnet-evm/precompile/precompiletest/test_precompile.go b/graft/subnet-evm/precompile/precompiletest/test_precompile.go index 8fc617f42916..9f8a15456bc1 100644 --- a/graft/subnet-evm/precompile/precompiletest/test_precompile.go +++ b/graft/subnet-evm/precompile/precompiletest/test_precompile.go @@ -127,10 +127,7 @@ func (test PrecompileTest) Bench(b *testing.B, module modules.Module) { } b.StopTimer() - elapsed := uint64(time.Since(start)) - if elapsed < 1 { - elapsed = 1 - } + elapsed := max(uint64(time.Since(start)), 1) gasUsed := runParams.SuppliedGas * uint64(b.N) b.ReportMetric(float64(runParams.SuppliedGas), "gas/op") // Keep it as uint64, multiply 100 to get two digit float later diff --git a/graft/subnet-evm/precompile/precompiletest/test_predicate.go b/graft/subnet-evm/precompile/precompiletest/test_predicate.go index 4a1a961ba088..f788197bf4ee 100644 --- a/graft/subnet-evm/precompile/precompiletest/test_predicate.go +++ b/graft/subnet-evm/precompile/precompiletest/test_predicate.go @@ -63,10 +63,7 @@ func (test PredicateTest) RunBenchmark(b *testing.B) { test.Run(b) } b.StopTimer() - elapsed := uint64(time.Since(start)) - if elapsed < 1 { - elapsed = 1 - } + elapsed := max(uint64(time.Since(start)), 1) gasUsed := test.Gas * uint64(b.N) b.ReportMetric(float64(test.Gas), "gas/op") diff --git a/graft/subnet-evm/tests/utils/proposervm.go b/graft/subnet-evm/tests/utils/proposervm.go index a30e885fb3b7..a58f9429773d 100644 --- a/graft/subnet-evm/tests/utils/proposervm.go +++ b/graft/subnet-evm/tests/utils/proposervm.go @@ -45,7 +45,7 @@ func IssueTxsToActivateProposerVMFork( txSigner := types.LatestSignerForChainID(chainID) // Send exactly 2 transactions, waiting for each to be included in a block - for i := 0; i < expectedBlockHeight; i++ { + for range expectedBlockHeight { tx := types.NewTransaction( nonce, addr, common.Big1, ethparams.TxGas, gasPrice, nil) triggerTx, err := types.SignTx(tx, txSigner, fundedKey) diff --git a/graft/subnet-evm/tests/warp/warp_test.go b/graft/subnet-evm/tests/warp/warp_test.go index 55ba7ee01402..b1ab434d47c3 100644 --- a/graft/subnet-evm/tests/warp/warp_test.go +++ b/graft/subnet-evm/tests/warp/warp_test.go @@ -713,7 +713,7 @@ func (w *warpTest) warpLoad() { log.Info("Generating tx sequence to send warp messages...") warpSendSequences, err := txs.GenerateTxSequences(ctx, func(key *ecdsa.PrivateKey, nonce uint64) (*types.Transaction, error) { - data, err := warp.PackSendWarpMessage([]byte(fmt.Sprintf("Jets %d-%d Dolphins", key.X.Int64(), nonce))) + data, err := warp.PackSendWarpMessage(fmt.Appendf(nil, "Jets %d-%d Dolphins", key.X.Int64(), nonce)) if err != nil { return nil, err } diff --git a/ids/bits_test.go b/ids/bits_test.go index 993a3249acd3..3a0a03d722cc 100644 --- a/ids/bits_test.go +++ b/ids/bits_test.go @@ -74,12 +74,12 @@ func TestEqualSubsetAll3Bytes(t *testing.T) { t.Logf("seed: %d", seed) id1 := ID{}.Prefix(seed) - for i := 0; i < BitsPerByte; i++ { + for i := range BitsPerByte { for j := i; j < BitsPerByte; j++ { for k := j; k < BitsPerByte; k++ { id2 := ID{uint8(i), uint8(j), uint8(k)} - for start := 0; start < BitsPerByte*3; start++ { + for start := range BitsPerByte * 3 { for end := start; end <= BitsPerByte*3; end++ { require.Equal(t, Check(start, end, id1, id2), EqualSubset(start, end, id1, id2)) } diff --git a/indexer/client_test.go b/indexer/client_test.go index 93ab8b46e58e..d2c19cb1879d 100644 --- a/indexer/client_test.go +++ b/indexer/client_test.go @@ -19,10 +19,10 @@ import ( type mockClient struct { require *require.Assertions expectedMethod string - onSendRequestF func(reply interface{}) error + onSendRequestF func(reply any) error } -func (mc *mockClient) SendRequest(_ context.Context, method string, _ interface{}, reply interface{}, _ ...rpc.Option) error { +func (mc *mockClient) SendRequest(_ context.Context, method string, _ any, reply any, _ ...rpc.Option) error { mc.require.Equal(mc.expectedMethod, method) return mc.onSendRequestF(reply) } @@ -35,7 +35,7 @@ func TestIndexClient(t *testing.T) { client.Requester = &mockClient{ require: require, expectedMethod: "index.getIndex", - onSendRequestF: func(reply interface{}) error { + onSendRequestF: func(reply any) error { *(reply.(*GetIndexResponse)) = GetIndexResponse{Index: 5} return nil }, @@ -53,7 +53,7 @@ func TestIndexClient(t *testing.T) { client.Requester = &mockClient{ require: require, expectedMethod: "index.getLastAccepted", - onSendRequestF: func(reply interface{}) error { + onSendRequestF: func(reply any) error { *(reply.(*FormattedContainer)) = FormattedContainer{ ID: id, Bytes: bytesStr, @@ -77,7 +77,7 @@ func TestIndexClient(t *testing.T) { client.Requester = &mockClient{ require: require, expectedMethod: "index.getContainerRange", - onSendRequestF: func(reply interface{}) error { + onSendRequestF: func(reply any) error { *(reply.(*GetContainerRangeResponse)) = GetContainerRangeResponse{Containers: []FormattedContainer{{ ID: id, Bytes: bytesStr, @@ -96,7 +96,7 @@ func TestIndexClient(t *testing.T) { client.Requester = &mockClient{ require: require, expectedMethod: "index.isAccepted", - onSendRequestF: func(reply interface{}) error { + onSendRequestF: func(reply any) error { *(reply.(*IsAcceptedResponse)) = IsAcceptedResponse{IsAccepted: true} return nil }, @@ -114,7 +114,7 @@ func TestIndexClient(t *testing.T) { client.Requester = &mockClient{ require: require, expectedMethod: "index.getContainerByID", - onSendRequestF: func(reply interface{}) error { + onSendRequestF: func(reply any) error { *(reply.(*FormattedContainer)) = FormattedContainer{ ID: id, Bytes: bytesStr, diff --git a/indexer/index_test.go b/indexer/index_test.go index 5460cdfd4d22..0511e8cefb36 100644 --- a/indexer/index_test.go +++ b/indexer/index_test.go @@ -115,7 +115,7 @@ func TestIndexGetContainerByRangeMaxPageSize(t *testing.T) { require.NoError(err) // Insert [MaxFetchedByRange] + 1 containers - for i := uint64(0); i < MaxFetchedByRange+1; i++ { + for range uint64(MaxFetchedByRange + 1) { require.NoError(idx.Accept(ctx, ids.GenerateTestID(), utils.RandomBytes(32))) } diff --git a/nat/nat.go b/nat/nat.go index a18469dedc10..b0cdb856f69f 100644 --- a/nat/nat.go +++ b/nat/nat.go @@ -96,7 +96,7 @@ func (m *Mapper) Map( // Retry port map up to maxRefreshRetries with a 1 second delay func (m *Mapper) retryMapPort(intPort, extPort uint16, desc string, timeout time.Duration) error { var err error - for retryCnt := 0; retryCnt < maxRefreshRetries; retryCnt++ { + for retryCnt := range maxRefreshRetries { err = m.r.MapPort(intPort, extPort, desc, timeout) if err == nil { return nil diff --git a/nat/upnp.go b/nat/upnp.go index 73d0a9e987ca..233bdc63ba32 100644 --- a/nat/upnp.go +++ b/nat/upnp.go @@ -167,7 +167,7 @@ func discover(target string) *upnpRouter { } router := make(chan *upnpRouter) - for i := 0; i < len(devs); i++ { + for i := range devs { if devs[i].Root == nil { continue } @@ -201,7 +201,7 @@ func discover(target string) *upnpRouter { }(&devs[i]) } - for i := 0; i < len(devs); i++ { + for range devs { if r := <-router; r != nil { return r } @@ -226,7 +226,7 @@ func getUPnPRouter() *upnpRouter { }(urn) } - for i := 0; i < len(targets); i++ { + for range targets { if r := <-routers; r != nil { return r } diff --git a/network/ip_tracker_test.go b/network/ip_tracker_test.go index 0bddd353cc3e..ee455623e1f2 100644 --- a/network/ip_tracker_test.go +++ b/network/ip_tracker_test.go @@ -2164,7 +2164,7 @@ func TestIPTracker_BloomGrows(t *testing.T) { tracker := newTestIPTracker(t, false) initialMaxBloomCount := tracker.maxBloomCount - for i := 0; i < 2048; i++ { + for range 2048 { test.add(tracker) } requireMetricsConsistent(t, tracker) diff --git a/network/network.go b/network/network.go index 27d3b258537f..563656ba15d4 100644 --- a/network/network.go +++ b/network/network.go @@ -359,7 +359,7 @@ func (n *network) Send( // HealthCheck returns information about several network layer health checks. // 1) Information about health check results // 2) An error if the health check reports unhealthy -func (n *network) HealthCheck(context.Context) (interface{}, error) { +func (n *network) HealthCheck(context.Context) (any, error) { n.peersLock.RLock() connectedTo := n.connectedPeers.Len() n.peersLock.RUnlock() @@ -369,7 +369,7 @@ func (n *network) HealthCheck(context.Context) (interface{}, error) { // Make sure we're connected to at least the minimum number of peers isConnected := connectedTo >= int(n.config.HealthConfig.MinConnectedPeers) healthy := isConnected - details := map[string]interface{}{ + details := map[string]any{ ConnectedPeersKey: connectedTo, } diff --git a/network/network_test.go b/network/network_test.go index 6ede1d6e428f..9d08cb9cdcc6 100644 --- a/network/network_test.go +++ b/network/network_test.go @@ -166,7 +166,7 @@ func newTestNetwork(t *testing.T, count int, baseConfig Config) (*testDialer, [] nodeIDs = make([]ids.NodeID, count) configs = make([]*Config, count) ) - for i := 0; i < count; i++ { + for i := range count { ip, listener := dialer.NewListener() tlsCert, err := staking.NewTLSCert() diff --git a/network/no_ingress_conn_alert.go b/network/no_ingress_conn_alert.go index f1d6b57e810d..c23170124fdf 100644 --- a/network/no_ingress_conn_alert.go +++ b/network/no_ingress_conn_alert.go @@ -22,11 +22,11 @@ type validatorRetriever interface { GetValidator(subnetID ids.ID, nodeID ids.NodeID) (*validators.Validator, bool) } -func checkNoIngressConnections(selfID ids.NodeID, ingressConnections ingressConnectionCounter, validators validatorRetriever) (interface{}, error) { +func checkNoIngressConnections(selfID ids.NodeID, ingressConnections ingressConnectionCounter, validators validatorRetriever) (any, error) { connCount := ingressConnections.IngressConnCount() _, areWeValidator := validators.GetValidator(constants.PrimaryNetworkID, selfID) - result := map[string]interface{}{ + result := map[string]any{ "ingressConnectionCount": connCount, "primaryNetworkValidator": areWeValidator, } diff --git a/network/no_ingress_conn_alert_test.go b/network/no_ingress_conn_alert_test.go index 7859604e59cc..8b8e9e0c5487 100644 --- a/network/no_ingress_conn_alert_test.go +++ b/network/no_ingress_conn_alert_test.go @@ -34,23 +34,23 @@ func TestNoIngressConnAlertHealthCheck(t *testing.T) { getValidatorResult bool ingressConnCountResult int expectedErr error - expectedResult interface{} + expectedResult any }{ { name: "not a validator of a primary network", - expectedResult: map[string]interface{}{"ingressConnectionCount": 0, "primaryNetworkValidator": false}, + expectedResult: map[string]any{"ingressConnectionCount": 0, "primaryNetworkValidator": false}, }, { name: "a validator of the primary network", getValidatorResult: true, - expectedResult: map[string]interface{}{ + expectedResult: map[string]any{ "ingressConnectionCount": 0, "primaryNetworkValidator": true, }, expectedErr: ErrNoIngressConnections, }, { name: "a validator with ingress connections", - expectedResult: map[string]interface{}{"ingressConnectionCount": 42, "primaryNetworkValidator": true}, + expectedResult: map[string]any{"ingressConnectionCount": 42, "primaryNetworkValidator": true}, expectedErr: nil, ingressConnCountResult: 42, getValidatorResult: true, diff --git a/network/p2p/gossip/gossip_test.go b/network/p2p/gossip/gossip_test.go index b5112fea02d0..286e3775a0b7 100644 --- a/network/p2p/gossip/gossip_test.go +++ b/network/p2p/gossip/gossip_test.go @@ -44,12 +44,10 @@ func TestGossiperShutdown(t *testing.T) { ctx, cancel := context.WithCancel(t.Context()) wg := &sync.WaitGroup{} - wg.Add(1) - go func() { + wg.Go(func() { Every(ctx, logging.NoLog{}, gossiper, time.Second) - wg.Done() - }() + }) cancel() wg.Wait() diff --git a/network/p2p/peer_tracker_test.go b/network/p2p/peer_tracker_test.go index e7a8a0ad7fff..10388c55796b 100644 --- a/network/p2p/peer_tracker_test.go +++ b/network/p2p/peer_tracker_test.go @@ -69,7 +69,7 @@ func TestPeerTracker(t *testing.T) { // Expect requests to go to responsive or new peers, so long as they are available numRequests := 50 - for i := 0; i < numRequests; i++ { + for i := range numRequests { peer, ok := p.SelectPeer() require.True(ok) require.NotZero(peer) diff --git a/network/peer/info.go b/network/peer/info.go index ec8434d8aa59..ad45df17e419 100644 --- a/network/peer/info.go +++ b/network/peer/info.go @@ -14,7 +14,7 @@ import ( type Info struct { IP netip.AddrPort `json:"ip"` - PublicIP netip.AddrPort `json:"publicIP,omitempty"` + PublicIP netip.AddrPort `json:"publicIP"` ID ids.NodeID `json:"nodeID"` Version string `json:"version"` UpgradeTime uint64 `json:"upgradeTime"` diff --git a/network/peer/message_queue_test.go b/network/peer/message_queue_test.go index 2c4e9a117770..ba8a202a7749 100644 --- a/network/peer/message_queue_test.go +++ b/network/peer/message_queue_test.go @@ -30,19 +30,19 @@ func TestMessageQueue(t *testing.T) { numToSend := 10 // Assert that the messages are popped in the same order they were pushed - for i := 0; i < numToSend; i++ { + for i := range numToSend { m, err := mc.Ping(uint32(i)) require.NoError(err) msgs = append(msgs, m) } go func() { - for i := 0; i < numToSend; i++ { + for i := range numToSend { q.Push(t.Context(), msgs[i]) } }() - for i := 0; i < numToSend; i++ { + for i := range numToSend { msg, ok := q.Pop() require.True(ok) require.Equal(msgs[i], msg) diff --git a/network/peer/peer.go b/network/peer/peer.go index a54319e466c0..e8aca41bfec4 100644 --- a/network/peer/peer.go +++ b/network/peer/peer.go @@ -195,7 +195,7 @@ type peer struct { lastSent, lastReceived int64 // lastPingSent is the milliseconds since 1970-01-01 UTC when the last ping was sent - lastPingSent int64 + lastPingSent atomic.Int64 // getPeerListChan signals that we should attempt to send a GetPeerList to // this peer @@ -622,7 +622,7 @@ func (p *peer) writeMessage(writer io.Writer, msg *message.OutboundMessage) { } if msg.Op == message.PingOp { - atomic.StoreInt64(&p.lastPingSent, p.Clock.Time().UnixMilli()) + p.lastPingSent.Store(p.Clock.Time().UnixMilli()) } // Write the message @@ -832,7 +832,7 @@ func (p *peer) getUptime() uint32 { } func (p *peer) handlePong(*p2p.Pong) { - pingSent := atomic.SwapInt64(&p.lastPingSent, 0) + pingSent := p.lastPingSent.Swap(0) if pingSent == 0 { p.Log.Debug(malformedMessageLog, zap.Stringer("nodeID", p.id), diff --git a/network/throttling/inbound_conn_upgrade_throttler_test.go b/network/throttling/inbound_conn_upgrade_throttler_test.go index 301132cfd4a9..a2da8df7cc10 100644 --- a/network/throttling/inbound_conn_upgrade_throttler_test.go +++ b/network/throttling/inbound_conn_upgrade_throttler_test.go @@ -30,7 +30,7 @@ func TestNoInboundConnUpgradeThrottler(t *testing.T) { }, ) // throttler should allow all - for i := 0; i < 10; i++ { + for range 10 { require.True(throttler.ShouldUpgrade(host1)) } } @@ -42,7 +42,7 @@ func TestNoInboundConnUpgradeThrottler(t *testing.T) { }, ) // throttler should allow all - for i := 0; i < 10; i++ { + for range 10 { require.True(throttler.ShouldUpgrade(host1)) } } diff --git a/network/throttling/inbound_resource_throttler.go b/network/throttling/inbound_resource_throttler.go index 29b4b933aba1..1871689c9d60 100644 --- a/network/throttling/inbound_resource_throttler.go +++ b/network/throttling/inbound_resource_throttler.go @@ -107,7 +107,7 @@ func NewSystemThrottler( targeter: targeter, tracker: tracker, timerPool: sync.Pool{ - New: func() interface{} { + New: func() any { // Satisfy invariant that timer is stopped and drained. return timerpkg.StoppedTimer() }, diff --git a/network/tracked_ip_test.go b/network/tracked_ip_test.go index f6ad01d8cc5b..87c8bc401dff 100644 --- a/network/tracked_ip_test.go +++ b/network/tracked_ip_test.go @@ -84,7 +84,7 @@ func TestTrackedIP(t *testing.T) { ip.increaseDelay(time.Second, time.Minute) require.LessOrEqual(ip.getDelay(), 32*time.Second) - for i := 0; i < 100; i++ { + for range 100 { ip.increaseDelay(time.Second, time.Minute) require.LessOrEqual(ip.getDelay(), time.Minute) } diff --git a/node/beacon_manager.go b/node/beacon_manager.go index afec2552f713..6814fcd93e05 100644 --- a/node/beacon_manager.go +++ b/node/beacon_manager.go @@ -20,7 +20,7 @@ type beaconManager struct { router.ExternalHandler beacons validators.Manager requiredConns int64 - numConns int64 + numConns atomic.Int64 onSufficientlyConnected chan struct{} onceOnSufficientlyConnected sync.Once } @@ -29,7 +29,7 @@ func (b *beaconManager) Connected(nodeID ids.NodeID, nodeVersion *version.Applic _, isBeacon := b.beacons.GetValidator(constants.PrimaryNetworkID, nodeID) if isBeacon && constants.PrimaryNetworkID == subnetID && - atomic.AddInt64(&b.numConns, 1) >= b.requiredConns { + b.numConns.Add(1) >= b.requiredConns { b.onceOnSufficientlyConnected.Do(func() { close(b.onSufficientlyConnected) }) @@ -39,7 +39,7 @@ func (b *beaconManager) Connected(nodeID ids.NodeID, nodeVersion *version.Applic func (b *beaconManager) Disconnected(nodeID ids.NodeID) { if _, isBeacon := b.beacons.GetValidator(constants.PrimaryNetworkID, nodeID); isBeacon { - atomic.AddInt64(&b.numConns, -1) + b.numConns.Add(-1) } b.ExternalHandler.Disconnected(nodeID) } diff --git a/node/beacon_manager_test.go b/node/beacon_manager_test.go index c4d83fff8015..d9a037bbbbb4 100644 --- a/node/beacon_manager_test.go +++ b/node/beacon_manager_test.go @@ -34,7 +34,7 @@ func TestBeaconManager_DataRace(t *testing.T) { validatorIDs := make([]ids.NodeID, 0, numValidators) validatorSet := validators.NewManager() - for i := 0; i < numValidators; i++ { + for range numValidators { nodeID := ids.GenerateTestNodeID() require.NoError(validatorSet.AddStaker(constants.PrimaryNetworkID, nodeID, nil, ids.Empty, 1)) @@ -62,7 +62,7 @@ func TestBeaconManager_DataRace(t *testing.T) { wg.Wait() // we should have a weight of numValidators now - require.Equal(int64(numValidators), b.numConns) + require.Equal(int64(numValidators), b.numConns.Load()) // disconnect numValidators validators wg.Add(numValidators) @@ -75,5 +75,5 @@ func TestBeaconManager_DataRace(t *testing.T) { wg.Wait() // we should a weight of zero now - require.Zero(b.numConns) + require.Zero(b.numConns.Load()) } diff --git a/node/node.go b/node/node.go index 8f3efc2f49f0..e228a56f6913 100644 --- a/node/node.go +++ b/node/node.go @@ -1445,7 +1445,7 @@ func (n *Node) initHealthAPI() error { return fmt.Errorf("couldn't register database health check: %w", err) } - diskSpaceCheck := health.CheckerFunc(func(context.Context) (interface{}, error) { + diskSpaceCheck := health.CheckerFunc(func(context.Context) (any, error) { // confirm that the node has enough disk space to continue operating // if there is too little disk space remaining, first report unhealthy and then shutdown the node @@ -1466,7 +1466,7 @@ func (n *Node) initHealthAPI() error { err = fmt.Errorf("remaining available disk space percentage (%d%%) is below warning threshold available space percentage (%d%%)", availableDiskPercentage, n.Config.WarningAvailableDiskSpacePercentage) } - return map[string]interface{}{ + return map[string]any{ "availableDiskBytes": availableDiskBytes, "availableDiskPercentage": availableDiskPercentage, }, err @@ -1477,7 +1477,7 @@ func (n *Node) initHealthAPI() error { return fmt.Errorf("couldn't register resource health check: %w", err) } - wrongBLSKeyCheck := health.CheckerFunc(func(context.Context) (interface{}, error) { + wrongBLSKeyCheck := health.CheckerFunc(func(context.Context) (any, error) { vdr, ok := n.vdrs.GetValidator(constants.PrimaryNetworkID, n.ID) if !ok { return "node is not a validator", nil @@ -1529,7 +1529,7 @@ func (n *Node) initHealthAPI() error { localUpgradeTimeUnix = uint64(localUpgradeTime.Unix()) lastLogTime time.Time ) - futureUpgradeCheck := health.CheckerFunc(func(context.Context) (interface{}, error) { + futureUpgradeCheck := health.CheckerFunc(func(context.Context) (any, error) { var ( currentValidators = n.vdrs.GetMap(constants.PrimaryNetworkID) totalWeight uint64 @@ -1560,7 +1560,7 @@ func (n *Node) initHealthAPI() error { } modeUpgradeWeightPortion := float64(modeUpgradeWeight) / float64(totalWeight) - result := map[string]interface{}{ + result := map[string]any{ "localUpgradeTime": localUpgradeTime, "modeUpgradeTime": time.Unix(int64(modeUpgradeTimeUnix), 0).UTC(), "modeUpgradeWeightPercentage": 100 * modeUpgradeWeightPortion, @@ -1831,8 +1831,8 @@ func (n *Node) shutdown() { if n.health != nil { // Passes if the node is not shutting down - shuttingDownCheck := health.CheckerFunc(func(context.Context) (interface{}, error) { - return map[string]interface{}{ + shuttingDownCheck := health.CheckerFunc(func(context.Context) (any, error) { + return map[string]any{ "isShuttingDown": true, }, errShuttingDown }) diff --git a/simplex/engine.go b/simplex/engine.go index ace4170cf162..56c254584ada 100644 --- a/simplex/engine.go +++ b/simplex/engine.go @@ -251,9 +251,9 @@ func (*Engine) Notify(_ context.Context, _ common.Message) error { return nil } -func (e *Engine) HealthCheck(ctx context.Context) (interface{}, error) { +func (e *Engine) HealthCheck(ctx context.Context) (any, error) { vmIntf, vmErr := e.vm.HealthCheck(ctx) - intf := map[string]interface{}{ + intf := map[string]any{ "consensus": struct{}{}, "vm": vmIntf, } diff --git a/simplex/engine_test.go b/simplex/engine_test.go index 9939975ac999..62180656a1b2 100644 --- a/simplex/engine_test.go +++ b/simplex/engine_test.go @@ -52,11 +52,11 @@ func TestSimplexEngineHandlesSimplexMessages(t *testing.T) { func TestHealthCheck(t *testing.T) { vmHealthErr := errors.New("vm health error") - vmHealthResult := map[string]interface{}{"healthy": true} + vmHealthResult := map[string]any{"healthy": true} tests := []struct { name string - vmResult interface{} + vmResult any vmErr error expectedErr error }{ @@ -77,14 +77,14 @@ func TestHealthCheck(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { engine, _ := setupEngine(t) - engine.vm.(*wrappedVM).VM.VM.HealthCheckF = func(context.Context) (interface{}, error) { + engine.vm.(*wrappedVM).VM.VM.HealthCheckF = func(context.Context) (any, error) { return tt.vmResult, tt.vmErr } result, err := engine.HealthCheck(t.Context()) require.ErrorIs(t, err, tt.expectedErr) - resultMap, ok := result.(map[string]interface{}) + resultMap, ok := result.(map[string]any) require.True(t, ok) require.Contains(t, resultMap, "consensus") require.Contains(t, resultMap, "vm") diff --git a/simplex/storage_test.go b/simplex/storage_test.go index 8dcc66528b91..628f287179e3 100644 --- a/simplex/storage_test.go +++ b/simplex/storage_test.go @@ -273,7 +273,7 @@ func TestStorageIndexSuccess(t *testing.T) { finalizations = append(finalizations, simplex.Finalization{}) prev := genesis - for i := 0; i < numBlocks; i++ { + for range numBlocks { child := newTestBlock(t, newBlockConfig{prev: prev}) _, err := child.Verify(ctx) require.NoError(t, err) diff --git a/simplex/util_test.go b/simplex/util_test.go index 0e6856e7ee2f..93cac11e0d24 100644 --- a/simplex/util_test.go +++ b/simplex/util_test.go @@ -150,7 +150,7 @@ func newSimplexChainParams(nodes []*testNode) *simplexparams.Parameters { func generateTestNodes(t *testing.T, num uint64) []*testNode { nodes := make([]*testNode, num) - for i := uint64(0); i < num; i++ { + for i := range num { ls, err := localsigner.New() require.NoError(t, err) diff --git a/snow/consensus/snowball/consensus_performance_test.go b/snow/consensus/snowball/consensus_performance_test.go index 6eafdb14984e..c0c5a9fa51ff 100644 --- a/snow/consensus/snowball/consensus_performance_test.go +++ b/snow/consensus/snowball/consensus_performance_test.go @@ -34,12 +34,12 @@ func TestDualAlphaOptimization(t *testing.T) { dualAlphaNetwork := NewNetwork(SnowballFactory, params, numColors, source) source.Seed(seed) - for i := 0; i < numNodes; i++ { + for range numNodes { dualAlphaNetwork.AddNode(NewTree) } source.Seed(seed) - for i := 0; i < numNodes; i++ { + for range numNodes { singleAlphaNetwork.AddNode(NewTree) } @@ -65,12 +65,12 @@ func TestTreeConvergenceOptimization(t *testing.T) { flatNetwork := NewNetwork(SnowballFactory, params, numColors, source) source.Seed(seed) - for i := 0; i < numNodes; i++ { + for range numNodes { treeNetwork.AddNode(NewTree) } source.Seed(seed) - for i := 0; i < numNodes; i++ { + for range numNodes { flatNetwork.AddNode(NewFlat) } diff --git a/snow/consensus/snowball/consensus_reversibility_test.go b/snow/consensus/snowball/consensus_reversibility_test.go index c691b20c94be..ca44909e05ea 100644 --- a/snow/consensus/snowball/consensus_reversibility_test.go +++ b/snow/consensus/snowball/consensus_reversibility_test.go @@ -26,7 +26,7 @@ func TestSnowballGovernance(t *testing.T) { nBitwise := NewNetwork(SnowballFactory, params, numColors, source) source.Seed(seed) - for i := 0; i < numRed; i++ { + for range numRed { nBitwise.AddNodeSpecificColor(NewTree, 0, []int{1}) } @@ -38,7 +38,7 @@ func TestSnowballGovernance(t *testing.T) { nBitwise.AddNodeSpecificColor(NewTree, 1, []int{0}) } - for i := 0; i < numByzantine; i++ { + for range numByzantine { nBitwise.AddNodeSpecificColor(NewByzantine, 1, []int{0}) } diff --git a/snow/consensus/snowball/network_test.go b/snow/consensus/snowball/network_test.go index 15d8e93826ba..5a43bf95f837 100644 --- a/snow/consensus/snowball/network_test.go +++ b/snow/consensus/snowball/network_test.go @@ -26,7 +26,7 @@ func NewNetwork(factory Factory, params Parameters, numColors int, rngSource sam rngSource: rngSource, factory: factory, } - for i := 0; i < numColors; i++ { + for i := range numColors { n.colors = append(n.colors, ids.Empty.Prefix(uint64(i))) } return n diff --git a/snow/consensus/snowball/nnary_snowball_test.go b/snow/consensus/snowball/nnary_snowball_test.go index baf6efbcb29a..2e91f098c748 100644 --- a/snow/consensus/snowball/nnary_snowball_test.go +++ b/snow/consensus/snowball/nnary_snowball_test.go @@ -101,7 +101,7 @@ func TestNarySnowballRecordUnsuccessfulPoll(t *testing.T) { expected := "SB(Preference = TtF4d2QWbk5vzQGTEPrN48x6vwgAoAmKQ9cbp79inpQmcRKES, PreferenceStrength = 3, SF(Confidence = [2], Finalized = true, SL(Preference = TtF4d2QWbk5vzQGTEPrN48x6vwgAoAmKQ9cbp79inpQmcRKES)))" require.Equal(expected, sb.String()) - for i := 0; i < 4; i++ { + for range 4 { sb.RecordPoll(alphaConfidence, Red) require.Equal(Blue, sb.Preference()) diff --git a/snow/consensus/snowball/tree_test.go b/snow/consensus/snowball/tree_test.go index d7c5904adca2..0bfef4d1b01e 100644 --- a/snow/consensus/snowball/tree_test.go +++ b/snow/consensus/snowball/tree_test.go @@ -690,7 +690,7 @@ func TestSnowball5Colors(t *testing.T) { } colors := []ids.ID{} - for i := 0; i < numColors; i++ { + for i := range numColors { colors = append(colors, ids.Empty.Prefix(uint64(i))) } @@ -847,7 +847,7 @@ func TestSnowballConsistent(t *testing.T) { n := NewNetwork(SnowballFactory, params, numColors, source) source.Seed(seed) - for i := 0; i < numNodes; i++ { + for range numNodes { n.AddNode(NewTree) } diff --git a/snow/consensus/snowball/unary_snowball_test.go b/snow/consensus/snowball/unary_snowball_test.go index 20c682ec71d8..ab93453a23bf 100644 --- a/snow/consensus/snowball/unary_snowball_test.go +++ b/snow/consensus/snowball/unary_snowball_test.go @@ -53,7 +53,7 @@ func TestUnarySnowball(t *testing.T) { require.Equal(expected, binarySnowball.String()) binarySnowball.RecordUnsuccessfulPoll() - for i := 0; i < 5; i++ { + for range 5 { require.Zero(binarySnowball.Preference()) require.False(binarySnowball.Finalized()) binarySnowball.RecordPoll(alphaConfidence, 1) diff --git a/snow/consensus/snowman/bootstrapper/requests.go b/snow/consensus/snowman/bootstrapper/requests.go index 62522bce1757..8585fa10c84f 100644 --- a/snow/consensus/snowman/bootstrapper/requests.go +++ b/snow/consensus/snowman/bootstrapper/requests.go @@ -28,7 +28,7 @@ func (r *requests) GetPeers(context.Context) set.Set[ids.NodeID] { r.pendingSend.Len(), ) nodeIDs := set.NewSet[ids.NodeID](numToSend) - for i := 0; i < numToSend; i++ { + for range numToSend { nodeID, _ := r.pendingSend.Pop() nodeIDs.Add(nodeID) } diff --git a/snow/consensus/snowman/consensus_test.go b/snow/consensus/snowman/consensus_test.go index b129f338b043..5f78a7209dc4 100644 --- a/snow/consensus/snowman/consensus_test.go +++ b/snow/consensus/snowman/consensus_test.go @@ -70,7 +70,7 @@ func runConsensusTests(t *testing.T, factory Factory) { } } -func getTestName(i interface{}) string { +func getTestName(i any) string { return strings.Split(path.Base(runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()), ".")[1] } @@ -1328,7 +1328,7 @@ func RandomizedConsistencyTest(t *testing.T, factory Factory) { n := NewNetwork(params, numColors, source) - for i := 0; i < numNodes; i++ { + for range numNodes { require.NoError(n.AddNode(t, factory.New())) } diff --git a/snow/consensus/snowman/mixed_test.go b/snow/consensus/snowman/mixed_test.go index 7ce0335b69fe..9f9f99c87cee 100644 --- a/snow/consensus/snowman/mixed_test.go +++ b/snow/consensus/snowman/mixed_test.go @@ -32,7 +32,7 @@ func TestConvergenceSnowFlakeSnowBall(t *testing.T) { t.Run(fmt.Sprintf("%d nodes", numNodes), func(t *testing.T) { n := NewNetwork(params, 10, prng.NewMT19937()) - for i := 0; i < numNodes; i++ { + for i := range numNodes { var sbFactory snowball.Factory if i%2 == 0 { sbFactory = snowball.SnowflakeFactory diff --git a/snow/consensus/snowman/topological.go b/snow/consensus/snowman/topological.go index 188bc2f2a98b..94ca26e9cbfb 100644 --- a/snow/consensus/snowman/topological.go +++ b/snow/consensus/snowman/topological.go @@ -313,7 +313,7 @@ func (ts *Topological) RecordPoll(ctx context.Context, voteBag bag.Bag[ids.ID]) } // HealthCheck returns information about the consensus health. -func (ts *Topological) HealthCheck(context.Context) (interface{}, error) { +func (ts *Topological) HealthCheck(context.Context) (any, error) { var errs []error numProcessingBlks := ts.NumProcessing() @@ -347,7 +347,7 @@ func (ts *Topological) HealthCheck(context.Context) (interface{}, error) { errs = append(errs, err) } - return map[string]interface{}{ + return map[string]any{ "processingBlocks": numProcessingBlks, "longestProcessingBlock": maxTimeProcessing.String(), // .String() is needed here to ensure a human readable format "avgAcceptanceTime": avgAcceptanceTime.String(), diff --git a/snow/engine/avalanche/bootstrap/bootstrapper.go b/snow/engine/avalanche/bootstrap/bootstrapper.go index c74f93c84077..7a90ab8219e1 100644 --- a/snow/engine/avalanche/bootstrap/bootstrapper.go +++ b/snow/engine/avalanche/bootstrap/bootstrapper.go @@ -389,12 +389,12 @@ func (b *Bootstrapper) Start(ctx context.Context, startReqID uint32) error { return b.startSyncing(ctx, nil) } -func (b *Bootstrapper) HealthCheck(ctx context.Context) (interface{}, error) { +func (b *Bootstrapper) HealthCheck(ctx context.Context) (any, error) { b.Ctx.Lock.Lock() defer b.Ctx.Lock.Unlock() vmIntf, vmErr := b.VM.HealthCheck(ctx) - intf := map[string]interface{}{ + intf := map[string]any{ "consensus": struct{}{}, "vm": vmIntf, } diff --git a/snow/engine/avalanche/engine.go b/snow/engine/avalanche/engine.go index d856bb532c05..2c685dd7fcda 100644 --- a/snow/engine/avalanche/engine.go +++ b/snow/engine/avalanche/engine.go @@ -65,6 +65,6 @@ func (e *engine) Context() *snow.ConsensusContext { return e.ctx } -func (*engine) HealthCheck(context.Context) (interface{}, error) { +func (*engine) HealthCheck(context.Context) (any, error) { return nil, nil } diff --git a/snow/engine/common/fx.go b/snow/engine/common/fx.go index 2e54d3f6e7eb..12679e12a624 100644 --- a/snow/engine/common/fx.go +++ b/snow/engine/common/fx.go @@ -8,5 +8,5 @@ import "github.com/ava-labs/avalanchego/ids" // Fx wraps an instance of a feature extension type Fx struct { ID ids.ID - Fx interface{} + Fx any } diff --git a/snow/engine/common/halter.go b/snow/engine/common/halter.go index bb0e92552bab..05b9cf42114f 100644 --- a/snow/engine/common/halter.go +++ b/snow/engine/common/halter.go @@ -13,13 +13,13 @@ type Haltable interface { } type Halter struct { - halted uint32 + halted atomic.Uint32 } func (h *Halter) Halt() { - atomic.StoreUint32(&h.halted, 1) + h.halted.Store(1) } func (h *Halter) Halted() bool { - return atomic.LoadUint32(&h.halted) == 1 + return h.halted.Load() == 1 } diff --git a/snow/engine/common/notifier_test.go b/snow/engine/common/notifier_test.go index 1d13c1be0064..38c8100720c4 100644 --- a/snow/engine/common/notifier_test.go +++ b/snow/engine/common/notifier_test.go @@ -78,10 +78,10 @@ func TestNotifierStopWhileSubscribing(_ *testing.T) { } func TestNotifierWaitForPrefChangeAfterNotify(t *testing.T) { - var notifiedCount uint32 + var notifiedCount atomic.Uint32 engine := Notifier(notifier(func(_ context.Context, _ Message) error { - atomic.AddUint32(¬ifiedCount, 1) + notifiedCount.Add(1) return nil })) @@ -93,21 +93,21 @@ func TestNotifierWaitForPrefChangeAfterNotify(t *testing.T) { defer nf.Close() require.Eventually(t, func() bool { - return atomic.LoadUint32(¬ifiedCount) == 1 + return notifiedCount.Load() == 1 }, time.Minute, 10*time.Millisecond) require.Never(t, func() bool { - return atomic.LoadUint32(¬ifiedCount) != 1 + return notifiedCount.Load() != 1 }, time.Millisecond*100, 10*time.Millisecond) nf.CheckForEvent() require.Eventually(t, func() bool { - return atomic.LoadUint32(¬ifiedCount) == 2 + return notifiedCount.Load() == 2 }, time.Minute, 10*time.Millisecond) require.Never(t, func() bool { - return atomic.LoadUint32(¬ifiedCount) != 2 + return notifiedCount.Load() != 2 }, time.Millisecond*100, 10*time.Millisecond) } diff --git a/snow/engine/common/traced_engine.go b/snow/engine/common/traced_engine.go index ed7498f5cef3..36370ff94950 100644 --- a/snow/engine/common/traced_engine.go +++ b/snow/engine/common/traced_engine.go @@ -362,7 +362,7 @@ func (e *tracedEngine) Start(ctx context.Context, startReqID uint32) error { return e.engine.Start(ctx, startReqID) } -func (e *tracedEngine) HealthCheck(ctx context.Context) (interface{}, error) { +func (e *tracedEngine) HealthCheck(ctx context.Context) (any, error) { ctx, span := e.tracer.Start(ctx, "tracedEngine.HealthCheck") defer span.End() diff --git a/snow/engine/enginetest/engine.go b/snow/engine/enginetest/engine.go index 06b29bc9bdab..eee42de71354 100644 --- a/snow/engine/enginetest/engine.go +++ b/snow/engine/enginetest/engine.go @@ -129,7 +129,7 @@ type Engine struct { AcceptedStateSummaryF func(ctx context.Context, nodeID ids.NodeID, requestID uint32, summaryIDs set.Set[ids.ID]) error ConnectedF func(ctx context.Context, nodeID ids.NodeID, nodeVersion *version.Application) error DisconnectedF func(ctx context.Context, nodeID ids.NodeID) error - HealthF func(context.Context) (interface{}, error) + HealthF func(context.Context) (any, error) GetVMF func() common.VM AppRequestF func(ctx context.Context, nodeID ids.NodeID, requestID uint32, deadline time.Time, msg []byte) error AppResponseF func(ctx context.Context, nodeID ids.NodeID, requestID uint32, msg []byte) error @@ -607,7 +607,7 @@ func (e *Engine) Disconnected(ctx context.Context, nodeID ids.NodeID) error { return errDisconnected } -func (e *Engine) HealthCheck(ctx context.Context) (interface{}, error) { +func (e *Engine) HealthCheck(ctx context.Context) (any, error) { if e.HealthF != nil { return e.HealthF(ctx) } diff --git a/snow/engine/enginetest/vm.go b/snow/engine/enginetest/vm.go index ca7b3693ad11..ab8850ab4a54 100644 --- a/snow/engine/enginetest/vm.go +++ b/snow/engine/enginetest/vm.go @@ -53,7 +53,7 @@ type VM struct { NewHTTPHandlerF func(context.Context) (http.Handler, error) ConnectedF func(ctx context.Context, nodeID ids.NodeID, nodeVersion *version.Application) error DisconnectedF func(ctx context.Context, nodeID ids.NodeID) error - HealthCheckF func(context.Context) (interface{}, error) + HealthCheckF func(context.Context) (any, error) AppRequestF func(ctx context.Context, nodeID ids.NodeID, requestID uint32, deadline time.Time, msg []byte) error AppResponseF func(ctx context.Context, nodeID ids.NodeID, requestID uint32, msg []byte) error AppGossipF func(ctx context.Context, nodeID ids.NodeID, msg []byte) error @@ -160,7 +160,7 @@ func (vm *VM) NewHTTPHandler(ctx context.Context) (http.Handler, error) { return nil, nil } -func (vm *VM) HealthCheck(ctx context.Context) (interface{}, error) { +func (vm *VM) HealthCheck(ctx context.Context) (any, error) { if vm.HealthCheckF != nil { return vm.HealthCheckF(ctx) } diff --git a/snow/engine/snowman/bootstrap/bootstrapper.go b/snow/engine/snowman/bootstrap/bootstrapper.go index 4e5bcfbf1fea..ac81aa345420 100644 --- a/snow/engine/snowman/bootstrap/bootstrapper.go +++ b/snow/engine/snowman/bootstrap/bootstrapper.go @@ -791,12 +791,12 @@ func (b *Bootstrapper) Notify(_ context.Context, msg common.Message) error { return nil } -func (b *Bootstrapper) HealthCheck(ctx context.Context) (interface{}, error) { +func (b *Bootstrapper) HealthCheck(ctx context.Context) (any, error) { b.Ctx.Lock.Lock() defer b.Ctx.Lock.Unlock() vmIntf, vmErr := b.VM.HealthCheck(ctx) - intf := map[string]interface{}{ + intf := map[string]any{ "consensus": struct{}{}, "vm": vmIntf, } diff --git a/snow/engine/snowman/engine.go b/snow/engine/snowman/engine.go index 258fadc98c0c..09550f93f9e6 100644 --- a/snow/engine/snowman/engine.go +++ b/snow/engine/snowman/engine.go @@ -527,7 +527,7 @@ func (e *Engine) Start(ctx context.Context, startReqID uint32) error { return e.executeDeferredWork(ctx) } -func (e *Engine) HealthCheck(ctx context.Context) (interface{}, error) { +func (e *Engine) HealthCheck(ctx context.Context) (any, error) { e.Ctx.Lock.Lock() defer e.Ctx.Lock.Unlock() @@ -541,7 +541,7 @@ func (e *Engine) HealthCheck(ctx context.Context) (interface{}, error) { consensusIntf, consensusErr := e.Consensus.HealthCheck(ctx) vmIntf, vmErr := e.VM.HealthCheck(ctx) - intf := map[string]interface{}{ + intf := map[string]any{ "consensus": consensusIntf, "vm": vmIntf, } diff --git a/snow/engine/snowman/syncer/state_syncer.go b/snow/engine/snowman/syncer/state_syncer.go index 0ba8015c1c4b..5f6d4e1484f4 100644 --- a/snow/engine/snowman/syncer/state_syncer.go +++ b/snow/engine/snowman/syncer/state_syncer.go @@ -601,12 +601,12 @@ func (*stateSyncer) Timeout(context.Context) error { return nil } -func (ss *stateSyncer) HealthCheck(ctx context.Context) (interface{}, error) { +func (ss *stateSyncer) HealthCheck(ctx context.Context) (any, error) { ss.Ctx.Lock.Lock() defer ss.Ctx.Lock.Unlock() vmIntf, vmErr := ss.VM.HealthCheck(ctx) - intf := map[string]interface{}{ + intf := map[string]any{ "consensus": struct{}{}, "vm": vmIntf, } diff --git a/snow/engine/snowman/syncer/utils_test.go b/snow/engine/snowman/syncer/utils_test.go index 706ad9f329a5..97a87af0c782 100644 --- a/snow/engine/snowman/syncer/utils_test.go +++ b/snow/engine/snowman/syncer/utils_test.go @@ -62,7 +62,7 @@ func buildTestPeers(t *testing.T, subnetID ids.ID) validators.Manager { // We consider more than maxOutstandingBroadcastRequests peers to test // capping the number of requests sent out. vdrs := validators.NewManager() - for idx := 0; idx < 2*maxOutstandingBroadcastRequests; idx++ { + for range 2 * maxOutstandingBroadcastRequests { beaconID := ids.GenerateTestNodeID() require.NoError(t, vdrs.AddStaker(subnetID, beaconID, nil, ids.Empty, 1)) } diff --git a/snow/networking/handler/health.go b/snow/networking/handler/health.go index 09f29d832be2..2e036a20a403 100644 --- a/snow/networking/handler/health.go +++ b/snow/networking/handler/health.go @@ -14,7 +14,7 @@ import ( var ErrNotConnectedEnoughStake = errors.New("not connected to enough stake") -func (h *handler) HealthCheck(ctx context.Context) (interface{}, error) { +func (h *handler) HealthCheck(ctx context.Context) (any, error) { state := h.ctx.State.Get() engine, ok := h.engineManager.Get(state.Type).Get(state.State) if !ok { @@ -27,7 +27,7 @@ func (h *handler) HealthCheck(ctx context.Context) (interface{}, error) { } engineIntf, engineErr := engine.HealthCheck(ctx) networkingIntf, networkingErr := h.networkHealthCheck() - intf := map[string]interface{}{ + intf := map[string]any{ "engine": engineIntf, "networking": networkingIntf, } @@ -40,9 +40,9 @@ func (h *handler) HealthCheck(ctx context.Context) (interface{}, error) { return intf, fmt.Errorf("engine: %w; networking: %w", engineErr, networkingErr) } -func (h *handler) networkHealthCheck() (interface{}, error) { +func (h *handler) networkHealthCheck() (any, error) { percentConnected := h.peerTracker.ConnectedPercent() - details := map[string]interface{}{ + details := map[string]any{ "percentConnected": percentConnected, "disconnectedValidators": h.getDisconnectedValidators(), } diff --git a/snow/networking/handler/health_test.go b/snow/networking/handler/health_test.go index 789fb596670a..5cb942a37677 100644 --- a/snow/networking/handler/health_test.go +++ b/snow/networking/handler/health_test.go @@ -134,7 +134,7 @@ func TestHealthCheckSubnet(t *testing.T) { testVdrCount := 4 vdrIDs := set.NewSet[ids.NodeID](testVdrCount) - for i := 0; i < testVdrCount; i++ { + for range testVdrCount { vdrID := ids.GenerateTestNodeID() vdrIDs.Add(vdrID) @@ -154,10 +154,10 @@ func TestHealthCheckSubnet(t *testing.T) { } require.ErrorIs(err, ErrNotConnectedEnoughStake) - detailsMap, ok := details.(map[string]interface{}) + detailsMap, ok := details.(map[string]any) require.True(ok) require.Equal( - map[string]interface{}{ + map[string]any{ "percentConnected": expectedPercentConnected, "disconnectedValidators": set.Of(vdrIDsList[index+1:]...), }, diff --git a/snow/networking/router/chain_router.go b/snow/networking/router/chain_router.go index eebf2c298344..f40934a2618e 100644 --- a/snow/networking/router/chain_router.go +++ b/snow/networking/router/chain_router.go @@ -671,14 +671,14 @@ func (cr *ChainRouter) Unbenched(chainID ids.ID, nodeID ids.NodeID) { // HealthCheck returns results of router health checks. Returns: // 1) Information about health check results // 2) An error if the health check reports unhealthy -func (cr *ChainRouter) HealthCheck(context.Context) (interface{}, error) { +func (cr *ChainRouter) HealthCheck(context.Context) (any, error) { cr.lock.Lock() defer cr.lock.Unlock() numOutstandingReqs := cr.timedRequests.Len() isOutstandingReqs := numOutstandingReqs <= cr.healthConfig.MaxOutstandingRequests healthy := isOutstandingReqs - details := map[string]interface{}{ + details := map[string]any{ "outstandingRequests": numOutstandingReqs, } diff --git a/snow/networking/router/traced_router.go b/snow/networking/router/traced_router.go index c49d84449806..5a53d746425a 100644 --- a/snow/networking/router/traced_router.go +++ b/snow/networking/router/traced_router.go @@ -153,7 +153,7 @@ func (r *tracedRouter) Unbenched(chainID ids.ID, nodeID ids.NodeID) { r.router.Unbenched(chainID, nodeID) } -func (r *tracedRouter) HealthCheck(ctx context.Context) (interface{}, error) { +func (r *tracedRouter) HealthCheck(ctx context.Context) (any, error) { ctx, span := r.tracer.Start(ctx, "tracedRouter.HealthCheck") defer span.End() diff --git a/snow/networking/sender/sender_test.go b/snow/networking/sender/sender_test.go index cf2c560fe588..558584fe54cc 100644 --- a/snow/networking/sender/sender_test.go +++ b/snow/networking/sender/sender_test.go @@ -418,7 +418,7 @@ func TestReliableMessages(t *testing.T) { } queriesToSend := 1000 awaiting := make([]chan struct{}, queriesToSend) - for i := 0; i < queriesToSend; i++ { + for i := range queriesToSend { awaiting[i] = make(chan struct{}, 1) } bootstrapper.QueryFailedF = func(_ context.Context, _ ids.NodeID, reqID uint32) error { @@ -451,7 +451,7 @@ func TestReliableMessages(t *testing.T) { h.Start(t.Context(), false) go func() { - for i := 0; i < queriesToSend; i++ { + for i := range queriesToSend { vdrIDs := set.Of(ids.BuildTestNodeID([]byte{1})) sender.SendPullQuery(t.Context(), vdrIDs, uint32(i), ids.Empty, 0) @@ -580,7 +580,7 @@ func TestReliableMessagesToMyself(t *testing.T) { } queriesToSend := 2 awaiting := make([]chan struct{}, queriesToSend) - for i := 0; i < queriesToSend; i++ { + for i := range queriesToSend { awaiting[i] = make(chan struct{}, 1) } bootstrapper.QueryFailedF = func(_ context.Context, _ ids.NodeID, reqID uint32) error { @@ -612,7 +612,7 @@ func TestReliableMessagesToMyself(t *testing.T) { h.Start(t.Context(), false) go func() { - for i := 0; i < queriesToSend; i++ { + for i := range queriesToSend { // Send a pull query to some random peer that won't respond // because they don't exist. This will almost immediately trigger // a query failed message diff --git a/snow/validators/gvalidators/validator_state_test.go b/snow/validators/gvalidators/validator_state_test.go index 018cc73929b3..ac0d6ff8ee9e 100644 --- a/snow/validators/gvalidators/validator_state_test.go +++ b/snow/validators/gvalidators/validator_state_test.go @@ -229,7 +229,7 @@ func setupValidatorSet(b *testing.B, size int) map[ids.NodeID]*validators.GetVal sk, err := localsigner.New() require.NoError(b, err) pk := sk.PublicKey() - for i := 0; i < size; i++ { + for i := range size { id := ids.GenerateTestNodeID() set[id] = &validators.GetValidatorOutput{ NodeID: id, diff --git a/tests/e2e/c/api.go b/tests/e2e/c/api.go index 95941cb85faf..4b9c1811e687 100644 --- a/tests/e2e/c/api.go +++ b/tests/e2e/c/api.go @@ -34,7 +34,7 @@ var _ = e2e.DescribeCChain("[ProposerVM API]", ginkgo.Label("proposervm"), func( recipientKey := e2e.NewPrivateKey(tc) recipientEthAddress := recipientKey.EthAddress() - for i := 0; i < 3; i++ { + for range 3 { // Create and send a simple transaction to trigger block production nonce, err := ethClient.AcceptedNonceAt(tc.DefaultContext(), senderEthAddress) require.NoError(err) diff --git a/tests/e2e/p/staking_rewards.go b/tests/e2e/p/staking_rewards.go index 84e7f2f10a6e..4772bc14ac2f 100644 --- a/tests/e2e/p/staking_rewards.go +++ b/tests/e2e/p/staking_rewards.go @@ -324,9 +324,9 @@ func getRewardConfig(tc tests.TestContext, client *admin.Client) reward.Config { rawNodeConfigMap, err := client.GetConfig(tc.DefaultContext()) require.NoError(err) - nodeConfigMap, ok := rawNodeConfigMap.(map[string]interface{}) + nodeConfigMap, ok := rawNodeConfigMap.(map[string]any) require.True(ok) - stakingConfigMap, ok := nodeConfigMap["stakingConfig"].(map[string]interface{}) + stakingConfigMap, ok := nodeConfigMap["stakingConfig"].(map[string]any) require.True(ok) var rewardConfig reward.Config diff --git a/tests/e2e/p/validator_sets.go b/tests/e2e/p/validator_sets.go index a427cae40683..50162c3c74e0 100644 --- a/tests/e2e/p/validator_sets.go +++ b/tests/e2e/p/validator_sets.go @@ -55,7 +55,7 @@ var _ = e2e.DescribePChain("[Validator Sets]", func() { weight = genesis.LocalParams.StakingConfig.MinDelegatorStake ) - for i := 0; i < delegatorCount; i++ { + for range delegatorCount { _, err := pWallet.IssueAddPermissionlessDelegatorTx( &txs.SubnetValidator{ Validator: txs.Validator{ diff --git a/tests/e2e/vms/xsvm.go b/tests/e2e/vms/xsvm.go index 35bc91e9f85a..1fc940f1b4a8 100644 --- a/tests/e2e/vms/xsvm.go +++ b/tests/e2e/vms/xsvm.go @@ -230,7 +230,7 @@ var _ = ginkgo.Describe("[XSVM]", ginkgo.Label("xsvm"), func() { n := 10 eg.Go(func() error { - for i := 0; i < n; i++ { + for i := range n { msg := fmt.Sprintf("ping-%d", i) if err := stream.Send(&xsvm.StreamPingRequest{ Message: msg, @@ -245,7 +245,7 @@ var _ = ginkgo.Describe("[XSVM]", ginkgo.Label("xsvm"), func() { }) eg.Go(func() error { - for i := 0; i < n; i++ { + for i := range n { reply, err := stream.Receive() if err != nil { return err diff --git a/tests/e2e/x/transfer/virtuous.go b/tests/e2e/x/transfer/virtuous.go index 7ba336beb6d2..a6a3bcb2f318 100644 --- a/tests/e2e/x/transfer/virtuous.go +++ b/tests/e2e/x/transfer/virtuous.go @@ -300,7 +300,7 @@ var _ = e2e.DescribeXChainSerial("[Virtuous Transfer Tx AVAX]", func() { } } - for i := 0; i < totalRounds; i++ { + for i := range totalRounds { runFunc(i) } diff --git a/tests/fixture/bootstrapmonitor/common.go b/tests/fixture/bootstrapmonitor/common.go index d739b9b6e8d7..059d1d6a3bd2 100644 --- a/tests/fixture/bootstrapmonitor/common.go +++ b/tests/fixture/bootstrapmonitor/common.go @@ -62,7 +62,7 @@ func setImageDetails(ctx context.Context, log logging.Logger, clientset *kuberne } // Create the JSON patch - patchData := []map[string]interface{}{ + patchData := []map[string]any{ { "op": "replace", "path": "/spec/template/spec/containers/0/image", diff --git a/tests/fixture/e2e/describe.go b/tests/fixture/e2e/describe.go index 47ea473e11aa..fd27542f5f10 100644 --- a/tests/fixture/e2e/describe.go +++ b/tests/fixture/e2e/describe.go @@ -15,25 +15,25 @@ const ( ) // DescribeXChain annotates the tests for X-Chain. -func DescribeXChain(text string, args ...interface{}) bool { +func DescribeXChain(text string, args ...any) bool { args = append(args, ginkgo.Label("x")) return ginkgo.Describe("[X-Chain] "+text, args...) } // DescribeXChainSerial annotates serial tests for X-Chain. -func DescribeXChainSerial(text string, args ...interface{}) bool { +func DescribeXChainSerial(text string, args ...any) bool { args = append(args, ginkgo.Serial) return DescribeXChain(text, args...) } // DescribePChain annotates the tests for P-Chain. -func DescribePChain(text string, args ...interface{}) bool { +func DescribePChain(text string, args ...any) bool { args = append(args, ginkgo.Label("p")) return ginkgo.Describe("[P-Chain] "+text, args...) } // DescribeCChain annotates the tests for C-Chain. -func DescribeCChain(text string, args ...interface{}) bool { +func DescribeCChain(text string, args ...any) bool { args = append(args, ginkgo.Label("c")) return ginkgo.Describe("[C-Chain] "+text, args...) } diff --git a/tests/fixture/e2e/ginkgo_test_context.go b/tests/fixture/e2e/ginkgo_test_context.go index 80ff29c0a936..e12f86996d9d 100644 --- a/tests/fixture/e2e/ginkgo_test_context.go +++ b/tests/fixture/e2e/ginkgo_test_context.go @@ -77,7 +77,7 @@ func NewTestContext() *GinkgoTestContext { } } -func (*GinkgoTestContext) Errorf(format string, args ...interface{}) { +func (*GinkgoTestContext) Errorf(format string, args ...any) { ginkgo.GinkgoT().Errorf(format, args...) } diff --git a/tests/fixture/tmpnet/check_monitoring.go b/tests/fixture/tmpnet/check_monitoring.go index aec8882fe201..1a342547e34c 100644 --- a/tests/fixture/tmpnet/check_monitoring.go +++ b/tests/fixture/tmpnet/check_monitoring.go @@ -133,7 +133,7 @@ func queryLoki( Status string `json:"status"` Data struct { Result []struct { - Value []interface{} `json:"value"` + Value []any `json:"value"` } `json:"result"` } `json:"data"` } diff --git a/tests/fixture/tmpnet/kube.go b/tests/fixture/tmpnet/kube.go index e301f3984fc4..73ced077a5f5 100644 --- a/tests/fixture/tmpnet/kube.go +++ b/tests/fixture/tmpnet/kube.go @@ -403,9 +403,9 @@ func applyManifest( ) error { // Split the manifest into individual resources decoder := yaml.NewDecodingSerializer(unstructured.UnstructuredJSONScheme) - documents := strings.Split(string(manifest), "\n---\n") + documents := strings.SplitSeq(string(manifest), "\n---\n") - for _, doc := range documents { + for doc := range documents { doc := strings.TrimSpace(doc) if strings.TrimSpace(doc) == "" || strings.HasPrefix(doc, "#") { continue diff --git a/tests/fixture/tmpnet/network_config.go b/tests/fixture/tmpnet/network_config.go index 3659672b86e6..943ff241d454 100644 --- a/tests/fixture/tmpnet/network_config.go +++ b/tests/fixture/tmpnet/network_config.go @@ -158,7 +158,7 @@ type serializedNetworkConfig struct { PrimarySubnetConfig ConfigMap `json:"primarySubnetConfig,omitempty"` PrimaryChainConfigs map[string]ConfigMap `json:"primaryChainConfigs,omitempty"` DefaultFlags FlagsMap `json:"defaultFlags,omitempty"` - DefaultRuntimeConfig NodeRuntimeConfig `json:"defaultRuntimeConfig,omitempty"` + DefaultRuntimeConfig NodeRuntimeConfig `json:"defaultRuntimeConfig"` PreFundedKeys []*secp256k1.PrivateKey `json:"preFundedKeys,omitempty"` } diff --git a/tests/fixture/tmpnet/utils.go b/tests/fixture/tmpnet/utils.go index 4f3165890e4d..7abb72c604df 100644 --- a/tests/fixture/tmpnet/utils.go +++ b/tests/fixture/tmpnet/utils.go @@ -115,7 +115,7 @@ func GetNodeWebsocketURIs( } // Marshal to json with default prefix and indent. -func DefaultJSONMarshal(v interface{}) ([]byte, error) { +func DefaultJSONMarshal(v any) ([]byte, error) { bytes, err := json.MarshalIndent(v, "", " ") if err != nil { return nil, stacktrace.Errorf("failed to marshal to json: %w", err) @@ -126,7 +126,7 @@ func DefaultJSONMarshal(v interface{}) ([]byte, error) { // Helper simplifying creation of a set of private keys func NewPrivateKeys(keyCount int) ([]*secp256k1.PrivateKey, error) { keys := make([]*secp256k1.PrivateKey, 0, keyCount) - for i := 0; i < keyCount; i++ { + for range keyCount { key, err := secp256k1.NewPrivateKey() if err != nil { return nil, stacktrace.Errorf("failed to generate private key: %w", err) diff --git a/utils/bag/bag_benchmark_test.go b/utils/bag/bag_benchmark_test.go index 569e391a32f7..6be8d4e7248c 100644 --- a/utils/bag/bag_benchmark_test.go +++ b/utils/bag/bag_benchmark_test.go @@ -12,7 +12,7 @@ func BenchmarkBagListSmall(b *testing.B) { rand := rand.New(rand.NewSource(1337)) //#nosec G404 smallLen := 5 bag := Bag[int]{} - for i := 0; i < smallLen; i++ { + for range smallLen { bag.Add(rand.Int()) } b.ResetTimer() @@ -25,7 +25,7 @@ func BenchmarkBagListMedium(b *testing.B) { rand := rand.New(rand.NewSource(1337)) //#nosec G404 mediumLen := 25 bag := Bag[int]{} - for i := 0; i < mediumLen; i++ { + for range mediumLen { bag.Add(rand.Int()) } b.ResetTimer() @@ -39,7 +39,7 @@ func BenchmarkBagListLarge(b *testing.B) { rand := rand.New(rand.NewSource(1337)) //#nosec G404 largeLen := 100000 bag := Bag[int]{} - for i := 0; i < largeLen; i++ { + for range largeLen { bag.Add(rand.Int()) } b.ResetTimer() diff --git a/utils/buffer/bounded_nonblocking_queue_test.go b/utils/buffer/bounded_nonblocking_queue_test.go index c1eedf399cfd..4420eab68ef0 100644 --- a/utils/buffer/bounded_nonblocking_queue_test.go +++ b/utils/buffer/bounded_nonblocking_queue_test.go @@ -39,7 +39,7 @@ func TestBoundedQueue(t *testing.T) { require.Zero(b.Len()) // Fill the queue - for i := 0; i < maxSize; i++ { + for i := range maxSize { b.Push(i) require.Equal(i+1, b.Len()) got, ok := b.Peek() @@ -55,7 +55,7 @@ func TestBoundedQueue(t *testing.T) { // Queue is [0, 1, 2] // Empty the queue - for i := 0; i < maxSize; i++ { + for i := range maxSize { got, ok := b.Pop() require.True(ok) require.Equal(i, got) @@ -75,7 +75,7 @@ func TestBoundedQueue(t *testing.T) { require.Empty(b.List()) // Fill the queue again - for i := 0; i < maxSize; i++ { + for i := range maxSize { b.Push(i) require.Equal(i+1, b.Len()) } @@ -120,7 +120,7 @@ func TestBoundedQueue(t *testing.T) { } // Empty the queue - for i := 0; i < maxSize; i++ { + for i := range maxSize { got, ok := b.Pop() require.True(ok) require.Equal(i+3, got) diff --git a/utils/buffer/unbounded_blocking_deque_test.go b/utils/buffer/unbounded_blocking_deque_test.go index 7ed139c51a71..84f6b9ea82fd 100644 --- a/utils/buffer/unbounded_blocking_deque_test.go +++ b/utils/buffer/unbounded_blocking_deque_test.go @@ -70,11 +70,9 @@ func TestUnboundedBlockingDequePop(t *testing.T) { ) wg := &sync.WaitGroup{} - wg.Add(1) - go func() { + wg.Go(func() { gotCh, gotOk = deque.PopLeft() - wg.Done() - }() + }) ok = deque.PushRight(2) require.True(ok) diff --git a/utils/buffer/unbounded_deque_test.go b/utils/buffer/unbounded_deque_test.go index 928fcb1c96be..92aaee2adfb6 100644 --- a/utils/buffer/unbounded_deque_test.go +++ b/utils/buffer/unbounded_deque_test.go @@ -653,7 +653,7 @@ func FuzzUnboundedSliceDeque(f *testing.F) { require.Equal(n, list[i]) } - for i := 0; i < len(input); i++ { + for i := range input { _, _ = b.PopLeft() list = b.List() if i == len(input)-1 { diff --git a/utils/bytes.go b/utils/bytes.go index 09cef914b383..1ed338fe6b16 100644 --- a/utils/bytes.go +++ b/utils/bytes.go @@ -51,7 +51,7 @@ func NewBytesPool() *BytesPool { // uint is used here to avoid overflowing int during the shift size := uint(1)< 0 && list[0] == startPrimaryWithBLS }), @@ -507,7 +507,7 @@ func TestTimestampListGenerator(t *testing.T) { gen.SliceOf(gen.OneConstOf( startPrimaryWithBLS, startSubnetValidator, - )).SuchThat(func(v interface{}) bool { + )).SuchThat(func(v any) bool { list := v.([]uint8) return len(list) > 0 && list[0] == startPrimaryWithBLS }), @@ -558,7 +558,7 @@ func TestTimestampListGenerator(t *testing.T) { gen.SliceOf(gen.OneConstOf( startPrimaryWithBLS, startSubnetValidator, - )).SuchThat(func(v interface{}) bool { + )).SuchThat(func(v any) bool { list := v.([]uint8) return len(list) > 0 && list[0] == startPrimaryWithBLS }), @@ -595,7 +595,7 @@ func TestTimestampListGenerator(t *testing.T) { gen.SliceOf(gen.OneConstOf( startPrimaryWithBLS, startSubnetValidator, - )).SuchThat(func(v interface{}) bool { + )).SuchThat(func(v any) bool { list := v.([]uint8) return len(list) > 0 && list[0] == startPrimaryWithBLS }), diff --git a/vms/platformvm/validators/fee/fee.go b/vms/platformvm/validators/fee/fee.go index 3e85d28fc569..1098f34f40d1 100644 --- a/vms/platformvm/validators/fee/fee.go +++ b/vms/platformvm/validators/fee/fee.go @@ -62,7 +62,7 @@ func (s State) CostOf(c Config, seconds uint64) uint64 { cost uint64 err error ) - for i := uint64(0); i < seconds; i++ { + for i := range seconds { s = s.AdvanceTime(c.Target, 1) // Advancing the time is going to either hold excess constant, @@ -109,7 +109,7 @@ func (s State) SecondsRemaining(c Config, maxSeconds uint64, fundsRemaining uint return min(seconds, maxSeconds) } - for seconds := uint64(0); seconds < maxSeconds; seconds++ { + for seconds := range maxSeconds { s = s.AdvanceTime(c.Target, 1) // Advancing the time is going to either hold excess constant, diff --git a/vms/platformvm/validators/fee/fee_test.go b/vms/platformvm/validators/fee/fee_test.go index 59c5f3e8c954..d8359d963bbc 100644 --- a/vms/platformvm/validators/fee/fee_test.go +++ b/vms/platformvm/validators/fee/fee_test.go @@ -537,7 +537,7 @@ func (s State) unoptimizedCostOf(c Config, seconds uint64) uint64 { cost uint64 err error ) - for i := uint64(0); i < seconds; i++ { + for range seconds { s = s.AdvanceTime(c.Target, 1) price := gas.CalculatePrice(c.MinPrice, s.Excess, c.ExcessConversionConstant) @@ -552,7 +552,7 @@ func (s State) unoptimizedCostOf(c Config, seconds uint64) uint64 { // unoptimizedSecondsRemaining is a naive implementation of SecondsRemaining // that is used for differential fuzzing. func (s State) unoptimizedSecondsRemaining(c Config, maxSeconds uint64, fundsRemaining uint64) uint64 { - for seconds := uint64(0); seconds < maxSeconds; seconds++ { + for seconds := range maxSeconds { s = s.AdvanceTime(c.Target, 1) price := uint64(gas.CalculatePrice(c.MinPrice, s.Excess, c.ExcessConversionConstant)) diff --git a/vms/platformvm/validators/manager_benchmark_test.go b/vms/platformvm/validators/manager_benchmark_test.go index 5a4be465a3c2..8c6d9da70fcd 100644 --- a/vms/platformvm/validators/manager_benchmark_test.go +++ b/vms/platformvm/validators/manager_benchmark_test.go @@ -70,7 +70,7 @@ func BenchmarkGetValidatorSet(b *testing.B) { nodeIDs []ids.NodeID currentHeight uint64 ) - for i := 0; i < 50; i++ { + for range 50 { currentHeight++ nodeID, err := addPrimaryValidator(s, genesistest.DefaultValidatorStartTime, genesistest.DefaultValidatorEndTime, currentHeight) require.NoError(err) @@ -81,7 +81,7 @@ func BenchmarkGetValidatorSet(b *testing.B) { currentHeight++ require.NoError(addSubnetValidator(s, subnetID, genesistest.DefaultValidatorStartTime, genesistest.DefaultValidatorEndTime, nodeID, currentHeight)) } - for i := 0; i < 9900; i++ { + for range 9900 { currentHeight++ require.NoError(addSubnetDelegator(s, subnetID, genesistest.DefaultValidatorStartTime, genesistest.DefaultValidatorEndTime, nodeIDs, currentHeight)) } diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go index fb9aef9d1f8e..704db5091a3c 100644 --- a/vms/platformvm/vm_regression_test.go +++ b/vms/platformvm/vm_regression_test.go @@ -2380,7 +2380,7 @@ func TestValidatorSetRaceCondition(t *testing.T) { ctx, cancel = context.WithCancel(t.Context()) ) // keep 10 workers running - for i := 0; i < 10; i++ { + for range 10 { eg.Go(func() error { for ctx.Err() == nil { err := vm.AppRequest( @@ -2399,7 +2399,7 @@ func TestValidatorSetRaceCondition(t *testing.T) { } // If the validator set lock isn't held, the race detector should fail here. - for i := uint64(0); i < 1000; i++ { + for i := range uint64(1000) { blk, err := block.NewBanffStandardBlock( time.Now(), vm.state.GetLastAccepted(), diff --git a/vms/platformvm/warp/validator_test.go b/vms/platformvm/warp/validator_test.go index 8a169b39ff92..56cdcfd105e0 100644 --- a/vms/platformvm/warp/validator_test.go +++ b/vms/platformvm/warp/validator_test.go @@ -314,7 +314,7 @@ func BenchmarkGetCanonicalValidatorSet(b *testing.B) { subnetID := ids.GenerateTestID() numNodes := 10_000 getValidatorOutputs := make([]*validators.GetValidatorOutput, 0, numNodes) - for i := 0; i < numNodes; i++ { + for range numNodes { nodeID := ids.GenerateTestNodeID() blsPrivateKey, err := localsigner.New() require.NoError(b, err) @@ -328,7 +328,7 @@ func BenchmarkGetCanonicalValidatorSet(b *testing.B) { for _, size := range []int{0, 1, 10, 100, 1_000, 10_000} { getValidatorsOutput := make(map[ids.NodeID]*validators.GetValidatorOutput) - for i := 0; i < size; i++ { + for i := range size { validator := getValidatorOutputs[i] getValidatorsOutput[validator.NodeID] = validator } diff --git a/vms/propertyfx/burn_operation_test.go b/vms/propertyfx/burn_operation_test.go index 6cfb93e26dc7..dd7662481d5e 100644 --- a/vms/propertyfx/burn_operation_test.go +++ b/vms/propertyfx/burn_operation_test.go @@ -26,7 +26,7 @@ func TestBurnOperationNumberOfOutput(t *testing.T) { } func TestBurnOperationState(t *testing.T) { - intf := interface{}(&BurnOperation{}) + intf := any(&BurnOperation{}) _, ok := intf.(verify.State) require.False(t, ok) } diff --git a/vms/propertyfx/credential_test.go b/vms/propertyfx/credential_test.go index 2a2dacffd23c..4171836b9620 100644 --- a/vms/propertyfx/credential_test.go +++ b/vms/propertyfx/credential_test.go @@ -12,7 +12,7 @@ import ( ) func TestCredentialState(t *testing.T) { - intf := interface{}(&Credential{}) + intf := any(&Credential{}) _, ok := intf.(verify.State) require.False(t, ok) } diff --git a/vms/propertyfx/fx.go b/vms/propertyfx/fx.go index ab2cc3cf3c52..462849cc5700 100644 --- a/vms/propertyfx/fx.go +++ b/vms/propertyfx/fx.go @@ -22,7 +22,7 @@ var ( type Fx struct{ secp256k1fx.Fx } -func (fx *Fx) Initialize(vmIntf interface{}) error { +func (fx *Fx) Initialize(vmIntf any) error { if err := fx.InitializeVM(vmIntf); err != nil { return err } @@ -40,7 +40,7 @@ func (fx *Fx) Initialize(vmIntf interface{}) error { ) } -func (fx *Fx) VerifyOperation(txIntf, opIntf, credIntf interface{}, utxosIntf []interface{}) error { +func (fx *Fx) VerifyOperation(txIntf, opIntf, credIntf any, utxosIntf []any) error { tx, ok := txIntf.(secp256k1fx.UnsignedTx) switch { case !ok: @@ -64,7 +64,7 @@ func (fx *Fx) VerifyOperation(txIntf, opIntf, credIntf interface{}, utxosIntf [] } } -func (fx *Fx) VerifyMintOperation(tx secp256k1fx.UnsignedTx, op *MintOperation, cred *Credential, utxoIntf interface{}) error { +func (fx *Fx) VerifyMintOperation(tx secp256k1fx.UnsignedTx, op *MintOperation, cred *Credential, utxoIntf any) error { out, ok := utxoIntf.(*MintOutput) if !ok { return errWrongUTXOType @@ -82,7 +82,7 @@ func (fx *Fx) VerifyMintOperation(tx secp256k1fx.UnsignedTx, op *MintOperation, } } -func (fx *Fx) VerifyTransferOperation(tx secp256k1fx.UnsignedTx, op *BurnOperation, cred *Credential, utxoIntf interface{}) error { +func (fx *Fx) VerifyTransferOperation(tx secp256k1fx.UnsignedTx, op *BurnOperation, cred *Credential, utxoIntf any) error { out, ok := utxoIntf.(*OwnedOutput) if !ok { return errWrongUTXOType @@ -95,6 +95,6 @@ func (fx *Fx) VerifyTransferOperation(tx secp256k1fx.UnsignedTx, op *BurnOperati return fx.VerifyCredentials(tx, &op.Input, &cred.Credential, &out.OutputOwners) } -func (*Fx) VerifyTransfer(_, _, _, _ interface{}) error { +func (*Fx) VerifyTransfer(_, _, _, _ any) error { return errCantTransfer } diff --git a/vms/propertyfx/fx_test.go b/vms/propertyfx/fx_test.go index 182479476d49..130d36850a47 100644 --- a/vms/propertyfx/fx_test.go +++ b/vms/propertyfx/fx_test.go @@ -90,7 +90,7 @@ func TestFxVerifyMintOperation(t *testing.T) { }}, } - utxos := []interface{}{utxo} + utxos := []any{utxo} require.NoError(fx.VerifyOperation(tx, op, cred, utxos)) } @@ -123,7 +123,7 @@ func TestFxVerifyMintOperationWrongTx(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(nil, op, cred, utxos) require.ErrorIs(err, errWrongTxType) } @@ -154,7 +154,7 @@ func TestFxVerifyMintOperationWrongNumberUTXOs(t *testing.T) { }, } - utxos := []interface{}{} + utxos := []any{} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, errWrongNumberOfUTXOs) } @@ -186,7 +186,7 @@ func TestFxVerifyMintOperationWrongCredential(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(tx, op, nil, utxos) require.ErrorIs(err, errWrongCredentialType) } @@ -217,7 +217,7 @@ func TestFxVerifyMintOperationInvalidUTXO(t *testing.T) { }, } - utxos := []interface{}{nil} + utxos := []any{nil} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, errWrongUTXOType) } @@ -255,7 +255,7 @@ func TestFxVerifyMintOperationFailingVerification(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, secp256k1fx.ErrAddrsNotSortedUnique) } @@ -292,7 +292,7 @@ func TestFxVerifyMintOperationInvalidGroupID(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, errWrongMintOutput) } @@ -327,7 +327,7 @@ func TestFxVerifyTransferOperation(t *testing.T) { SigIndices: []uint32{0}, }} - utxos := []interface{}{utxo} + utxos := []any{utxo} require.NoError(fx.VerifyOperation(tx, op, cred, utxos)) } @@ -355,7 +355,7 @@ func TestFxVerifyTransferOperationWrongUTXO(t *testing.T) { SigIndices: []uint32{0}, }} - utxos := []interface{}{nil} + utxos := []any{nil} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, errWrongUTXOType) } @@ -390,7 +390,7 @@ func TestFxVerifyTransferOperationFailedVerify(t *testing.T) { SigIndices: []uint32{1, 0}, }} - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, secp256k1fx.ErrInputIndicesNotSortedUnique) } @@ -422,7 +422,7 @@ func TestFxVerifyOperationUnknownOperation(t *testing.T) { }, }} - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(tx, nil, cred, utxos) require.ErrorIs(err, errWrongOperationType) } diff --git a/vms/propertyfx/mint_operation_test.go b/vms/propertyfx/mint_operation_test.go index 1e425ff7b3fa..5dd97cc5663b 100644 --- a/vms/propertyfx/mint_operation_test.go +++ b/vms/propertyfx/mint_operation_test.go @@ -36,7 +36,7 @@ func TestMintOperationOuts(t *testing.T) { } func TestMintOperationState(t *testing.T) { - intf := interface{}(&MintOperation{}) + intf := any(&MintOperation{}) _, ok := intf.(verify.State) require.False(t, ok) } diff --git a/vms/propertyfx/mint_output_test.go b/vms/propertyfx/mint_output_test.go index f0615872aa6c..6ad7c85be827 100644 --- a/vms/propertyfx/mint_output_test.go +++ b/vms/propertyfx/mint_output_test.go @@ -12,7 +12,7 @@ import ( ) func TestMintOutputState(t *testing.T) { - intf := interface{}(&MintOutput{}) + intf := any(&MintOutput{}) _, ok := intf.(verify.State) require.True(t, ok) } diff --git a/vms/propertyfx/owned_output_test.go b/vms/propertyfx/owned_output_test.go index 3cee82c6a5fe..30f5acacffdd 100644 --- a/vms/propertyfx/owned_output_test.go +++ b/vms/propertyfx/owned_output_test.go @@ -12,7 +12,7 @@ import ( ) func TestOwnedOutputState(t *testing.T) { - intf := interface{}(&OwnedOutput{}) + intf := any(&OwnedOutput{}) _, ok := intf.(verify.State) require.True(t, ok) } diff --git a/vms/proposervm/proposer/windower_test.go b/vms/proposervm/proposer/windower_test.go index e7f991279281..f10d8e97b99b 100644 --- a/vms/proposervm/proposer/windower_test.go +++ b/vms/proposervm/proposer/windower_test.go @@ -315,7 +315,7 @@ func TestCoherenceOfExpectedProposerAndMinDelayForProposer(t *testing.T) { pChainHeight uint64 = 0 ) - for slot := uint64(0); slot < 3*MaxLookAheadSlots; slot++ { + for slot := range uint64(3 * MaxLookAheadSlots) { proposerID, err := w.ExpectedProposer(dummyCtx, chainHeight, pChainHeight, slot) require.NoError(err) @@ -438,8 +438,8 @@ func TestProposerDistribution(t *testing.T) { // in the analysis. proposerFrequency[validatorID] = 0 } - for chainHeight := uint64(0); chainHeight < numChainHeights; chainHeight++ { - for slot := uint64(0); slot < numSlots; slot++ { + for chainHeight := range numChainHeights { + for slot := range numSlots { proposerID, err := w.ExpectedProposer(dummyCtx, chainHeight, pChainHeight, slot) require.NoError(err) proposerFrequency[proposerID]++ diff --git a/vms/proposervm/vm_test.go b/vms/proposervm/vm_test.go index eee823c27633..3234ede3e75e 100644 --- a/vms/proposervm/vm_test.go +++ b/vms/proposervm/vm_test.go @@ -2590,7 +2590,7 @@ func TestLocalParse(t *testing.T) { name string f block.ParseFunc block []byte - resultingBlock interface{} + resultingBlock any }{ { name: "local parse as post-fork", diff --git a/vms/rpcchainvm/factory.go b/vms/rpcchainvm/factory.go index c8e384393c15..7af9cffd38a4 100644 --- a/vms/rpcchainvm/factory.go +++ b/vms/rpcchainvm/factory.go @@ -41,7 +41,7 @@ func NewFactory( } } -func (f *factory) New(log logging.Logger) (interface{}, error) { +func (f *factory) New(log logging.Logger) (any, error) { config := &subprocess.Config{ Stderr: log, Stdout: log, diff --git a/vms/rpcchainvm/vm_client.go b/vms/rpcchainvm/vm_client.go index 6e1184db1d51..c7e11c2502c3 100644 --- a/vms/rpcchainvm/vm_client.go +++ b/vms/rpcchainvm/vm_client.go @@ -529,7 +529,7 @@ func (vm *VMClient) SetPreference(ctx context.Context, blkID ids.ID) error { return err } -func (vm *VMClient) HealthCheck(ctx context.Context) (interface{}, error) { +func (vm *VMClient) HealthCheck(ctx context.Context) (any, error) { // HealthCheck is a special case, where we want to fail fast instead of block. failFast := grpc.WaitForReady(false) health, err := vm.client.Health(ctx, &emptypb.Empty{}, failFast) diff --git a/vms/rpcchainvm/vm_server.go b/vms/rpcchainvm/vm_server.go index 612493c20b93..6aff48ebd1b1 100644 --- a/vms/rpcchainvm/vm_server.go +++ b/vms/rpcchainvm/vm_server.go @@ -520,7 +520,7 @@ func (vm *VMServer) Health(ctx context.Context, _ *emptypb.Empty) (*vmpb.HealthR if err != nil { return &vmpb.HealthResponse{}, err } - report := map[string]interface{}{ + report := map[string]any{ "database": dbHealth, "health": vmHealth, } diff --git a/vms/secp256k1fx/credential.go b/vms/secp256k1fx/credential.go index 2baa75175934..128b2bc238e9 100644 --- a/vms/secp256k1fx/credential.go +++ b/vms/secp256k1fx/credential.go @@ -29,7 +29,7 @@ func (cr *Credential) MarshalJSON() ([]byte, error) { } signatures[i] = sigStr } - jsonFieldMap := map[string]interface{}{ + jsonFieldMap := map[string]any{ "signatures": signatures, } return json.Marshal(jsonFieldMap) diff --git a/vms/secp256k1fx/credential_test.go b/vms/secp256k1fx/credential_test.go index 23d3c7b49d3a..7d855c8bf702 100644 --- a/vms/secp256k1fx/credential_test.go +++ b/vms/secp256k1fx/credential_test.go @@ -89,7 +89,7 @@ func TestCredentialSerialize(t *testing.T) { } func TestCredentialNotState(t *testing.T) { - intf := interface{}(&Credential{}) + intf := any(&Credential{}) _, ok := intf.(verify.State) require.False(t, ok) } diff --git a/vms/secp256k1fx/fx.go b/vms/secp256k1fx/fx.go index 199886debfe1..5ee772b5ce9d 100644 --- a/vms/secp256k1fx/fx.go +++ b/vms/secp256k1fx/fx.go @@ -40,7 +40,7 @@ type Fx struct { recoverCache *secp256k1.RecoverCache } -func (fx *Fx) Initialize(vmIntf interface{}) error { +func (fx *Fx) Initialize(vmIntf any) error { if err := fx.InitializeVM(vmIntf); err != nil { return err } @@ -59,7 +59,7 @@ func (fx *Fx) Initialize(vmIntf interface{}) error { ) } -func (fx *Fx) InitializeVM(vmIntf interface{}) error { +func (fx *Fx) InitializeVM(vmIntf any) error { vm, ok := vmIntf.(VM) if !ok { return ErrWrongVMType @@ -78,7 +78,7 @@ func (fx *Fx) Bootstrapped() error { } // VerifyPermission returns nil iff [credIntf] proves that [controlGroup] assents to [txIntf] -func (fx *Fx) VerifyPermission(txIntf, inIntf, credIntf, ownerIntf interface{}) error { +func (fx *Fx) VerifyPermission(txIntf, inIntf, credIntf, ownerIntf any) error { tx, ok := txIntf.(UnsignedTx) if !ok { return ErrWrongTxType @@ -101,7 +101,7 @@ func (fx *Fx) VerifyPermission(txIntf, inIntf, credIntf, ownerIntf interface{}) return fx.VerifyCredentials(tx, in, cred, owner) } -func (fx *Fx) VerifyOperation(txIntf, opIntf, credIntf interface{}, utxosIntf []interface{}) error { +func (fx *Fx) VerifyOperation(txIntf, opIntf, credIntf any, utxosIntf []any) error { tx, ok := txIntf.(UnsignedTx) if !ok { return ErrWrongTxType @@ -134,7 +134,7 @@ func (fx *Fx) verifyOperation(tx UnsignedTx, op *MintOperation, cred *Credential return fx.VerifyCredentials(tx, &op.MintInput, cred, &utxo.OutputOwners) } -func (fx *Fx) VerifyTransfer(txIntf, inIntf, credIntf, utxoIntf interface{}) error { +func (fx *Fx) VerifyTransfer(txIntf, inIntf, credIntf, utxoIntf any) error { tx, ok := txIntf.(UnsignedTx) if !ok { return ErrWrongTxType @@ -208,7 +208,7 @@ func (fx *Fx) VerifyCredentials(utx UnsignedTx, in *Input, cred *Credential, out // CreateOutput creates a new output with the provided control group worth // the specified amount -func (*Fx) CreateOutput(amount uint64, ownerIntf interface{}) (interface{}, error) { +func (*Fx) CreateOutput(amount uint64, ownerIntf any) (any, error) { owner, ok := ownerIntf.(*OutputOwners) if !ok { return nil, ErrWrongOwnerType diff --git a/vms/secp256k1fx/fx_test.go b/vms/secp256k1fx/fx_test.go index 9f2118a6399b..96483c17c8db 100644 --- a/vms/secp256k1fx/fx_test.go +++ b/vms/secp256k1fx/fx_test.go @@ -620,7 +620,7 @@ func TestFxVerifyOperation(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} require.NoError(fx.VerifyOperation(tx, op, cred, utxos)) } @@ -671,7 +671,7 @@ func TestFxVerifyOperationUnknownTx(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(nil, op, cred, utxos) require.ErrorIs(err, ErrWrongTxType) } @@ -701,7 +701,7 @@ func TestFxVerifyOperationUnknownOperation(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(tx, nil, cred, utxos) require.ErrorIs(err, ErrWrongOpType) } @@ -749,7 +749,7 @@ func TestFxVerifyOperationUnknownCredential(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(tx, op, nil, utxos) require.ErrorIs(err, ErrWrongCredentialType) } @@ -802,7 +802,7 @@ func TestFxVerifyOperationWrongNumberOfUTXOs(t *testing.T) { }, } - utxos := []interface{}{utxo, utxo} + utxos := []any{utxo, utxo} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, ErrWrongNumberOfUTXOs) } @@ -847,7 +847,7 @@ func TestFxVerifyOperationUnknownUTXOType(t *testing.T) { }, } - utxos := []interface{}{nil} + utxos := []any{nil} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, ErrWrongUTXOType) } @@ -897,7 +897,7 @@ func TestFxVerifyOperationInvalidOperationVerify(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, ErrOutputUnspendable) } @@ -945,7 +945,7 @@ func TestFxVerifyOperationMismatchedMintOutputs(t *testing.T) { }, } - utxos := []interface{}{utxo} + utxos := []any{utxo} err := fx.VerifyOperation(tx, op, cred, utxos) require.ErrorIs(err, ErrWrongMintCreated) } diff --git a/vms/secp256k1fx/mint_operation_test.go b/vms/secp256k1fx/mint_operation_test.go index b121bcde5503..bd9df417454a 100644 --- a/vms/secp256k1fx/mint_operation_test.go +++ b/vms/secp256k1fx/mint_operation_test.go @@ -157,7 +157,7 @@ func TestMintOperationOuts(t *testing.T) { func TestMintOperationState(t *testing.T) { require := require.New(t) - intf := interface{}(&MintOperation{}) + intf := any(&MintOperation{}) _, ok := intf.(verify.State) require.False(ok) } diff --git a/vms/secp256k1fx/output_owners.go b/vms/secp256k1fx/output_owners.go index f68c54eefad8..c8b012e021dd 100644 --- a/vms/secp256k1fx/output_owners.go +++ b/vms/secp256k1fx/output_owners.go @@ -57,7 +57,7 @@ func (out *OutputOwners) MarshalJSON() ([]byte, error) { // Fields returns JSON keys in a map that can be used with marshal JSON // to serialize OutputOwners struct -func (out *OutputOwners) Fields() (map[string]interface{}, error) { +func (out *OutputOwners) Fields() (map[string]any, error) { addresses := make([]string, len(out.Addrs)) for i, addr := range out.Addrs { // for each [addr] in [Addrs] we attempt to format it given @@ -70,7 +70,7 @@ func (out *OutputOwners) Fields() (map[string]interface{}, error) { } addresses[i] = fAddr } - result := map[string]interface{}{ + result := map[string]any{ "locktime": out.Locktime, "threshold": out.Threshold, "addresses": addresses, diff --git a/vms/secp256k1fx/transfer_input_test.go b/vms/secp256k1fx/transfer_input_test.go index b10bffc012f9..976ad81c5894 100644 --- a/vms/secp256k1fx/transfer_input_test.go +++ b/vms/secp256k1fx/transfer_input_test.go @@ -111,7 +111,7 @@ func TestTransferInputSerialize(t *testing.T) { func TestTransferInputNotState(t *testing.T) { require := require.New(t) - intf := interface{}(&TransferInput{}) + intf := any(&TransferInput{}) _, ok := intf.(verify.State) require.False(ok) } diff --git a/vms/secp256k1fx/transfer_output.go b/vms/secp256k1fx/transfer_output.go index d616638e1f0e..5467f464d4e2 100644 --- a/vms/secp256k1fx/transfer_output.go +++ b/vms/secp256k1fx/transfer_output.go @@ -53,6 +53,6 @@ func (out *TransferOutput) Verify() error { } } -func (out *TransferOutput) Owners() interface{} { +func (out *TransferOutput) Owners() any { return &out.OutputOwners } diff --git a/vms/secp256k1fx/transfer_output_test.go b/vms/secp256k1fx/transfer_output_test.go index fd01caf2618d..f3aa8a46b657 100644 --- a/vms/secp256k1fx/transfer_output_test.go +++ b/vms/secp256k1fx/transfer_output_test.go @@ -215,7 +215,7 @@ func TestOutputAddresses(t *testing.T) { func TestTransferOutputState(t *testing.T) { require := require.New(t) - intf := interface{}(&TransferOutput{}) + intf := any(&TransferOutput{}) _, ok := intf.(verify.State) require.True(ok) } diff --git a/x/archivedb/db.go b/x/archivedb/db.go index 47f7b85941ec..ebac549fb37b 100644 --- a/x/archivedb/db.go +++ b/x/archivedb/db.go @@ -96,7 +96,7 @@ func (db *Database) Compact(start []byte, limit []byte) error { return db.db.Compact(start, limit) } -func (db *Database) HealthCheck(ctx context.Context) (interface{}, error) { +func (db *Database) HealthCheck(ctx context.Context) (any, error) { return db.db.HealthCheck(ctx) } diff --git a/x/archivedb/prefix_test.go b/x/archivedb/prefix_test.go index 7f44b0623d45..e699600928c3 100644 --- a/x/archivedb/prefix_test.go +++ b/x/archivedb/prefix_test.go @@ -61,7 +61,7 @@ func TestDBEfficientLookups(t *testing.T) { require.NoError(batch.Put(key, []byte("value"))) require.NoError(batch.Write()) - for i := 0; i < 10000; i++ { + for i := range 10000 { batch = db.NewBatch(uint64(i) + 2) require.NoError(batch.Put(maliciousKey, []byte{byte(i)})) require.NoError(batch.Write()) diff --git a/x/blockdb/database_test.go b/x/blockdb/database_test.go index 95043b7f1e37..faa53ca22d93 100644 --- a/x/blockdb/database_test.go +++ b/x/blockdb/database_test.go @@ -412,7 +412,7 @@ func TestStructSizes(t *testing.T) { expectedBinarySize int expectedMarshalSize int expectedPadding uintptr - createInstance func() interface{} + createInstance func() any }{ { name: "indexFileHeader", @@ -422,7 +422,7 @@ func TestStructSizes(t *testing.T) { expectedBinarySize: 64, expectedMarshalSize: 64, expectedPadding: 0, - createInstance: func() interface{} { return indexFileHeader{} }, + createInstance: func() any { return indexFileHeader{} }, }, { name: "blockEntryHeader", @@ -432,7 +432,7 @@ func TestStructSizes(t *testing.T) { expectedBinarySize: 22, expectedMarshalSize: 22, expectedPadding: 10, - createInstance: func() interface{} { return blockEntryHeader{} }, + createInstance: func() any { return blockEntryHeader{} }, }, { name: "indexEntry", @@ -442,7 +442,7 @@ func TestStructSizes(t *testing.T) { expectedBinarySize: 16, expectedMarshalSize: 16, expectedPadding: 0, - createInstance: func() interface{} { return indexEntry{} }, + createInstance: func() any { return indexEntry{} }, }, } diff --git a/x/merkledb/cache_test.go b/x/merkledb/cache_test.go index cdc6647c8ef5..c568d9f8066f 100644 --- a/x/merkledb/cache_test.go +++ b/x/merkledb/cache_test.go @@ -187,7 +187,7 @@ func TestOnEvictCacheOnEvictionError(t *testing.T) { cache := newOnEvictCache(maxSize, size, onEviction) // Fill the cache - for i := 0; i < maxSize; i++ { + for i := range maxSize { require.NoError(cache.Put(i, i)) require.Equal(i+1, cache.fifo.Len()) } diff --git a/x/merkledb/codec.go b/x/merkledb/codec.go index 375aa8adb4bc..385ba33784dd 100644 --- a/x/merkledb/codec.go +++ b/x/merkledb/codec.go @@ -183,7 +183,7 @@ func decodeDBNode(b []byte, n *dbNode) error { n.children = make(map[byte]*child, numChildren) var previousChild uint64 - for i := uint64(0); i < numChildren; i++ { + for i := range numChildren { index, err := r.Uvarint() if err != nil { return err diff --git a/x/merkledb/codec_test.go b/x/merkledb/codec_test.go index 2fd70ce4ccce..1e5668ab5c5b 100644 --- a/x/merkledb/codec_test.go +++ b/x/merkledb/codec_test.go @@ -138,7 +138,7 @@ var ( value: maybe.Some([]byte("value")), children: make(map[byte]*child), } - for i := byte(0); i < 16; i++ { + for i := range byte(16) { n.children[i] = &child{ compressedKey: ToKey([]byte{i}), id: ids.ID{ @@ -499,7 +499,7 @@ func FuzzCodecDBNodeDeterministic(f *testing.F) { numChildren := r.Intn(int(bf)) children := map[byte]*child{} - for i := 0; i < numChildren; i++ { + for i := range numChildren { var childID ids.ID _, _ = r.Read(childID[:]) @@ -604,7 +604,7 @@ func TestUintSize(t *testing.T) { require.Equal(t, expectedSize, actualSize) // Test powers of 2 - for power := 0; power < 64; power++ { + for power := range 64 { n := uint64(1) << uint(power) expectedSize := uintSize(n) actualSize := binary.PutUvarint(make([]byte, binary.MaxVarintLen64), n) diff --git a/x/merkledb/db.go b/x/merkledb/db.go index 64ef4661a5b2..bac145d3f2f1 100644 --- a/x/merkledb/db.go +++ b/x/merkledb/db.go @@ -913,7 +913,7 @@ func (db *merkleDB) Has(k []byte) (bool, error) { return err == nil, err } -func (db *merkleDB) HealthCheck(ctx context.Context) (interface{}, error) { +func (db *merkleDB) HealthCheck(ctx context.Context) (any, error) { db.lock.RLock() defer db.lock.RUnlock() diff --git a/x/merkledb/db_test.go b/x/merkledb/db_test.go index de455e534c89..18d3d8408dc6 100644 --- a/x/merkledb/db_test.go +++ b/x/merkledb/db_test.go @@ -125,7 +125,7 @@ func Test_MerkleDB_DB_Load_Root_From_DB(t *testing.T) { keyCount := 100 ops := make([]database.BatchOp, 0, keyCount) require.NoError(err) - for i := 0; i < keyCount; i++ { + for i := range keyCount { k := []byte(strconv.Itoa(i)) ops = append(ops, database.BatchOp{ Key: k, @@ -175,7 +175,7 @@ func Test_MerkleDB_DB_Rebuild(t *testing.T) { // Populate initial set of keys ops := make([]database.BatchOp, 0, initialSize) require.NoError(err) - for i := 0; i < initialSize; i++ { + for i := range initialSize { k := []byte(strconv.Itoa(i)) ops = append(ops, database.BatchOp{ Key: k, @@ -718,7 +718,7 @@ func Test_MerkleDB_Random_Insert_Ordering(t *testing.T) { } } - for i := 0; i < numRuns; i++ { + for i := range numRuns { now := time.Now().UnixNano() t.Logf("seed for iter %d: %d", i, now) r := rand.New(rand.NewSource(now)) @@ -726,7 +726,7 @@ func Test_MerkleDB_Random_Insert_Ordering(t *testing.T) { // Insert key-value pairs into a database. ops := make([]database.BatchOp, 0, numKeyValues) keys = [][]byte{} - for x := 0; x < numKeyValues; x++ { + for range numKeyValues { key := genKey(r) value := make([]byte, r.Intn(51)) if r.Float64() < nilValueProbability { @@ -753,7 +753,7 @@ func Test_MerkleDB_Random_Insert_Ordering(t *testing.T) { // Assert that the same operations applied in a different order // result in the same root. Note this is only true because // all keys inserted are unique. - for shuffleIndex := 0; shuffleIndex < numShuffles; shuffleIndex++ { + for range numShuffles { r.Shuffle(numKeyValues, func(i, j int) { ops[i], ops[j] = ops[j], ops[i] }) @@ -1189,7 +1189,7 @@ func generateInitialValues( } var steps randTest - for i := uint(0); i < numInitialKeyValues; i++ { + for range numInitialKeyValues { step := randTestStep{ op: opUpdate, key: genKey(), @@ -1228,7 +1228,7 @@ func insertRandomKeyValues( require.GreaterOrEqual(deletePortion, float64(0)) require.LessOrEqual(deletePortion, float64(1)) - for i := uint(0); i < numKeyValues; i++ { + for range numKeyValues { keyLen := rand.Intn(maxKeyLen) key := make([]byte, keyLen) _, _ = rand.Read(key) @@ -1680,7 +1680,7 @@ func TestFindNextKeyRandom(t *testing.T) { // Put random keys into the databases for _, db := range []database.Database{remoteDB, localDB} { - for i := 0; i < numKeyValues; i++ { + for range numKeyValues { key := make([]byte, rand.Intn(maxKeyLen)) _, _ = rand.Read(key) val := make([]byte, rand.Intn(maxValLen)) @@ -1691,7 +1691,7 @@ func TestFindNextKeyRandom(t *testing.T) { // Repeatedly generate end proofs from the remote database and compare // the result of findNextKey to the expected result. - for proofIndex := 0; proofIndex < numProofsToTest; proofIndex++ { + for range numProofsToTest { // Generate a proof for a random key var ( rangeStart []byte diff --git a/x/merkledb/hashing_test.go b/x/merkledb/hashing_test.go index 5cc7fcb41a68..ce46152facf5 100644 --- a/x/merkledb/hashing_test.go +++ b/x/merkledb/hashing_test.go @@ -70,7 +70,7 @@ var sha256HashNodeTests = []struct { n: func() *node { n := newNode(Key{}) - for i := byte(0); i < 16; i++ { + for i := range byte(16) { childNode := newNode(ToKey([]byte{i << 4})) childNode.setValue(SHA256Hasher, maybe.Some([]byte("some value"))) @@ -95,7 +95,7 @@ func Fuzz_SHA256_HashNode(f *testing.F) { children := map[byte]*child{} numChildren := r.Intn(int(bf)) - for i := 0; i < numChildren; i++ { + for i := range numChildren { compressedKeyLen := r.Intn(32) compressedKeyBytes := make([]byte, compressedKeyLen) _, _ = r.Read(compressedKeyBytes) diff --git a/x/merkledb/helpers_test.go b/x/merkledb/helpers_test.go index c8128d9bdf37..6427efd379d0 100644 --- a/x/merkledb/helpers_test.go +++ b/x/merkledb/helpers_test.go @@ -59,7 +59,7 @@ func newRandomProofNode(r *rand.Rand) ProofNode { _, _ = r.Read(val) children := map[byte]ids.ID{} - for j := 0; j < 16; j++ { + for j := range 16 { if r.Float64() < 0.5 { var childID ids.ID _, _ = r.Read(childID[:]) diff --git a/x/merkledb/history_test.go b/x/merkledb/history_test.go index f7bc09e0010e..b1853d29e5d6 100644 --- a/x/merkledb/history_test.go +++ b/x/merkledb/history_test.go @@ -104,7 +104,7 @@ func Test_History_Large(t *testing.T) { t.Logf("seed for iter %d: %d", i, now) r := rand.New(rand.NewSource(now)) // make sure they stay in sync - for x := 0; x < numIters; x++ { + for range numIters { batch := db.NewBatch() addkey := make([]byte, r.Intn(50)) _, err := r.Read(addkey) @@ -725,7 +725,7 @@ func TestHistoryRecord(t *testing.T) { th := newTrieHistory(maxHistoryLen) changes := []*changeSummary{} - for i := 0; i < maxHistoryLen; i++ { // Fill the history + for i := range maxHistoryLen { // Fill the history changes = append(changes, &changeSummary{rootID: ids.GenerateTestID()}) th.record(changes[i]) diff --git a/x/merkledb/key_test.go b/x/merkledb/key_test.go index 2ff73aef89f9..2e8bf4d92f77 100644 --- a/x/merkledb/key_test.go +++ b/x/merkledb/key_test.go @@ -241,14 +241,14 @@ func Test_Key_Token(t *testing.T) { 0b1110_1111, }, assertTokens: func(require *require.Assertions, key Key) { - for i := 0; i < 16; i++ { + for i := range 16 { require.Equal(byte(i), key.Token(i*4, 4)) } }, }, } - for i := 0; i < 256; i++ { + for i := range 256 { tests = append(tests, test{ name: fmt.Sprintf("branch factor 256, byte %d", i), inputBytes: []byte{byte(i)}, diff --git a/x/merkledb/network_server_test.go b/x/merkledb/network_server_test.go index 8e08fb303bcd..77669c9af920 100644 --- a/x/merkledb/network_server_test.go +++ b/x/merkledb/network_server_test.go @@ -163,10 +163,10 @@ func Test_Server_GetChangeProof(t *testing.T) { require.NoError(t, err) // create changes - for x := 0; x < sync.DefaultRequestKeyLimit/2; x++ { + for range sync.DefaultRequestKeyLimit / 2 { ops := make([]database.BatchOp, 0, 11) // add some key/values - for i := 0; i < 10; i++ { + for range 10 { key := make([]byte, r.Intn(100)) _, err = r.Read(key) require.NoError(t, err) diff --git a/x/merkledb/proof.go b/x/merkledb/proof.go index 9e227b63d0ab..81278f183dca 100644 --- a/x/merkledb/proof.go +++ b/x/merkledb/proof.go @@ -9,6 +9,7 @@ import ( "errors" "fmt" "math" + "slices" "google.golang.org/protobuf/proto" @@ -541,7 +542,7 @@ func (c *ChangeProof) Empty() bool { func verifySortedKeyChanges(keyChanges []KeyChange, start maybe.Maybe[Key], end maybe.Maybe[Key]) error { hasLowerBound := start.HasValue() hasUpperBound := end.HasValue() - for i := 0; i < len(keyChanges); i++ { + for i := range keyChanges { if i < len(keyChanges)-1 && bytes.Compare(keyChanges[i].Key, keyChanges[i+1].Key) >= 0 { return ErrNonIncreasingValues } @@ -678,8 +679,7 @@ func addPathInfo( shouldInsertRightChildren = insertChildrenGreaterThan.HasValue() ) - for i := len(proofPath) - 1; i >= 0; i-- { - proofNode := proofPath[i] + for _, proofNode := range slices.Backward(proofPath) { key := proofNode.Key if key.hasPartialByte() && !proofNode.ValueOrHash.IsNothing() { diff --git a/x/merkledb/proof_test.go b/x/merkledb/proof_test.go index 30467ed3362a..f70fa996e7bb 100644 --- a/x/merkledb/proof_test.go +++ b/x/merkledb/proof_test.go @@ -1595,13 +1595,13 @@ func FuzzRangeProofProtoMarshalUnmarshal(f *testing.F) { // Make a random range proof. startProofLen := rand.Intn(32) startProof := make([]ProofNode, startProofLen) - for i := 0; i < startProofLen; i++ { + for i := range startProofLen { startProof[i] = newRandomProofNode(rand) } endProofLen := rand.Intn(32) endProof := make([]ProofNode, endProofLen) - for i := 0; i < endProofLen; i++ { + for i := range endProofLen { endProof[i] = newRandomProofNode(rand) } @@ -1635,13 +1635,13 @@ func FuzzChangeProofProtoMarshalUnmarshal(f *testing.F) { // Make a random change proof. startProofLen := rand.Intn(32) startProof := make([]ProofNode, startProofLen) - for i := 0; i < startProofLen; i++ { + for i := range startProofLen { startProof[i] = newRandomProofNode(rand) } endProofLen := rand.Intn(32) endProof := make([]ProofNode, endProofLen) - for i := 0; i < endProofLen; i++ { + for i := range endProofLen { endProof[i] = newRandomProofNode(rand) } @@ -1666,7 +1666,7 @@ func FuzzChangeProofProtoMarshalUnmarshal(f *testing.F) { func generateKeyChanges(rand *rand.Rand, numKeyChanges int, includeNone bool) []KeyChange { keyChanges := make([]KeyChange, numKeyChanges) - for i := 0; i < numKeyChanges; i++ { + for i := range numKeyChanges { var key []byte // length 0 is decoded as nil if keyLen := rand.Intn(32); keyLen != 0 { @@ -2032,7 +2032,7 @@ func Benchmark_ChangeProofs(b *testing.B) { db, err := getBasicDB() require.NoError(b, err) - for i := 0; i < historyChanges; i++ { + for i := range historyChanges { batch := db.NewBatch() for range changesPerHistory { key := make([]byte, rand.Intn(keyMaxLen)) diff --git a/x/merkledb/sync_test.go b/x/merkledb/sync_test.go index f34769015e60..8b5f86f1e797 100644 --- a/x/merkledb/sync_test.go +++ b/x/merkledb/sync_test.go @@ -288,7 +288,7 @@ func Test_Sync_Result_Correct_Root(t *testing.T) { // race condition in between writes where UpdateSyncTarget might // error because it has already reached the sync target before it // is called. - for i := 0; i < 50; i++ { + for range 50 { addkey := make([]byte, r.Intn(50)) _, err = r.Read(addkey) require.NoError(err) @@ -407,7 +407,7 @@ func Test_Sync_Result_Correct_Root_Update_Root_During(t *testing.T) { firstSyncRoot, err := dbToSync.GetMerkleRoot(t.Context()) require.NoError(err) - for x := 0; x < 100; x++ { + for range 100 { key := make([]byte, r.Intn(50)) _, err = r.Read(key) require.NoError(err) diff --git a/x/merkledb/trie_test.go b/x/merkledb/trie_test.go index f5e05b28a245..f4d4b8859007 100644 --- a/x/merkledb/trie_test.go +++ b/x/merkledb/trie_test.go @@ -927,7 +927,7 @@ func Test_Trie_MultipleStates(t *testing.T) { ops := make([]database.BatchOp, 0, initialSet) require.NoError(err) kv := [][]byte{} - for i := 0; i < initialSet; i++ { + for i := range initialSet { k := []byte(strconv.Itoa(i)) kv = append(kv, k) ops = append(ops, database.BatchOp{Key: k, Value: hashing.ComputeHash256(k)}) @@ -950,7 +950,7 @@ func Test_Trie_MultipleStates(t *testing.T) { // Populate additional states concurrentStates := []Trie{} - for i := 0; i < 5; i++ { + for range 5 { newState, err := root.NewView(t.Context(), ViewChanges{}) require.NoError(err) concurrentStates = append(concurrentStates, newState) @@ -963,7 +963,7 @@ func Test_Trie_MultipleStates(t *testing.T) { // Process ops newStart := initialSet concurrentOps := make([][]database.BatchOp, len(concurrentStates)) - for i := 0; i < 100; i++ { + for range 100 { if r.Intn(100) < 20 { // New Key for index := range concurrentStates { diff --git a/x/merkledb/value_node_db_test.go b/x/merkledb/value_node_db_test.go index c10f49087bf4..358cf030626d 100644 --- a/x/merkledb/value_node_db_test.go +++ b/x/merkledb/value_node_db_test.go @@ -124,7 +124,7 @@ func TestValueNodeDBIterator(t *testing.T) { ) // Put key-node pairs. - for i := 0; i < cacheSize; i++ { + for i := range cacheSize { key := ToKey([]byte{byte(i)}) node := &node{ dbNode: dbNode{ diff --git a/x/merkledb/view_iterator_test.go b/x/merkledb/view_iterator_test.go index 61ca80e98ddf..f658d545dffb 100644 --- a/x/merkledb/view_iterator_test.go +++ b/x/merkledb/view_iterator_test.go @@ -207,7 +207,7 @@ func Test_View_Iterator_Random(t *testing.T) { ) keyChanges := []KeyChange{} - for i := 0; i < numKeyChanges; i++ { + for range numKeyChanges { key := make([]byte, rand.Intn(maxKeyLen)) _, _ = rand.Read(key) value := make([]byte, rand.Intn(maxValLen)) @@ -281,7 +281,7 @@ func Test_View_Iterator_Random(t *testing.T) { iter = view3.NewIteratorWithStartAndPrefix(start, prefix) startPrefixUniqueKeys := []string{} // Remove keys that don't have the prefix/are before the start. - for i := 0; i < len(uniqueKeys); i++ { + for i := range uniqueKeys { if bytes.HasPrefix([]byte(uniqueKeys[i]), prefix) && bytes.Compare([]byte(uniqueKeys[i]), start) >= 0 { startPrefixUniqueKeys = append(startPrefixUniqueKeys, uniqueKeys[i]) } diff --git a/x/merkledb/view_test.go b/x/merkledb/view_test.go index fa96cfd1fd1d..20c8f1da406a 100644 --- a/x/merkledb/view_test.go +++ b/x/merkledb/view_test.go @@ -66,7 +66,7 @@ func makeViewForHashChangedNodes(t require.TestingT, numKeys uint64, parallelism require.NoError(t, err) ops := make([]database.BatchOp, 0, numKeys) - for i := uint64(0); i < numKeys; i++ { + for i := range numKeys { k := binary.AppendUvarint(nil, i) ops = append(ops, database.BatchOp{ Key: k,