diff --git a/api/admin/service_test.go b/api/admin/service_test.go
index b32928bcad50..80d3c188c1cf 100644
--- a/api/admin/service_test.go
+++ b/api/admin/service_test.go
@@ -75,10 +75,8 @@ func TestLoadVMsSuccess(t *testing.T) {
 
 	// execute test
 	reply := LoadVMsReply{}
-	err := resources.admin.LoadVMs(&http.Request{}, nil, &reply)
-
+	require.NoError(resources.admin.LoadVMs(&http.Request{}, nil, &reply))
 	require.Equal(expectedVMRegistry, reply.NewVMs)
-	require.NoError(err)
 }
 
 // Tests behavior for LoadVMs if we fail to reload vms.
diff --git a/api/auth/auth_test.go b/api/auth/auth_test.go
index 0094f2bec5b7..e691b11d8686 100644
--- a/api/auth/auth_test.go
+++ b/api/auth/auth_test.go
@@ -144,8 +144,7 @@ func TestRevokeToken(t *testing.T) {
 	tokenStr, err := auth.NewToken(testPassword, defaultTokenLifespan, endpoints)
 	require.NoError(err)
 
-	err = auth.RevokeToken(tokenStr, testPassword)
-	require.NoError(err)
+	require.NoError(auth.RevokeToken(tokenStr, testPassword))
 	require.Len(auth.revoked, 1)
 }
 
diff --git a/api/health/health_test.go b/api/health/health_test.go
index 792030fc1074..923f1f8558f5 100644
--- a/api/health/health_test.go
+++ b/api/health/health_test.go
@@ -247,9 +247,8 @@ func TestDeadlockRegression(t *testing.T) {
 
 	for i := 0; i < 1000; i++ {
 		lock.Lock()
-		err = h.RegisterHealthCheck(fmt.Sprintf("check-%d", i), check)
+		require.NoError(h.RegisterHealthCheck(fmt.Sprintf("check-%d", i), check))
 		lock.Unlock()
-		require.NoError(err)
 	}
 
 	awaitHealthy(t, h, true)
diff --git a/api/keystore/service_test.go b/api/keystore/service_test.go
index d26445878e18..a32fd6a716ad 100644
--- a/api/keystore/service_test.go
+++ b/api/keystore/service_test.go
@@ -40,11 +40,10 @@ func TestServiceCreateUser(t *testing.T) {
 	s := service{ks: ks.(*keystore)}
 
 	{
-		err := s.CreateUser(nil, &api.UserPass{
+		require.NoError(s.CreateUser(nil, &api.UserPass{
 			Username: "bob",
 			Password: strongPassword,
-		}, &api.EmptyReply{})
-		require.NoError(err)
+		}, &api.EmptyReply{}))
 	}
 
 	{
@@ -123,11 +122,10 @@ func TestServiceCreateDuplicate(t *testing.T) {
 	s := service{ks: ks.(*keystore)}
 
 	{
-		err := s.CreateUser(nil, &api.UserPass{
+		require.NoError(s.CreateUser(nil, &api.UserPass{
 			Username: "bob",
 			Password: strongPassword,
-		}, &api.EmptyReply{})
-		require.NoError(err)
+		}, &api.EmptyReply{}))
 	}
 
 	{
@@ -161,11 +159,10 @@ func TestServiceUseBlockchainDB(t *testing.T) {
 	s := service{ks: ks.(*keystore)}
 
 	{
-		err := s.CreateUser(nil, &api.UserPass{
+		require.NoError(s.CreateUser(nil, &api.UserPass{
 			Username: "bob",
 			Password: strongPassword,
-		}, &api.EmptyReply{})
-		require.NoError(err)
+		}, &api.EmptyReply{}))
 	}
 
 	{
@@ -193,11 +190,10 @@ func TestServiceExportImport(t *testing.T) {
 		s := service{ks: ks.(*keystore)}
 
 		{
-			err := s.CreateUser(nil, &api.UserPass{
+			require.NoError(s.CreateUser(nil, &api.UserPass{
 				Username: "bob",
 				Password: strongPassword,
-			}, &api.EmptyReply{})
-			require.NoError(err)
+			}, &api.EmptyReply{}))
 		}
 
 		{
@@ -243,15 +239,14 @@ func TestServiceExportImport(t *testing.T) {
 		}
 
 		{
-			err := newS.ImportUser(nil, &ImportUserArgs{
+			require.NoError(newS.ImportUser(nil, &ImportUserArgs{
 				UserPass: api.UserPass{
 					Username: "bob",
 					Password: strongPassword,
 				},
 				User:     exportReply.User,
 				Encoding: encoding,
-			}, &api.EmptyReply{})
-			require.NoError(err)
+			}, &api.EmptyReply{}))
 		}
 
 		{
diff --git a/chains/atomic/gsharedmemory/shared_memory_test.go b/chains/atomic/gsharedmemory/shared_memory_test.go
index 715e0e43e0d2..f8ae05ad6202 100644
--- a/chains/atomic/gsharedmemory/shared_memory_test.go
+++ b/chains/atomic/gsharedmemory/shared_memory_test.go
@@ -37,11 +37,8 @@ func TestInterface(t *testing.T) {
 
 		test(t, chainID0, chainID1, sm0, sm1, testDB)
 
-		err := conn0.Close()
-		require.NoError(err)
-
-		err = conn1.Close()
-		require.NoError(err)
+		require.NoError(conn0.Close())
+		require.NoError(conn1.Close())
 	}
 }
 
diff --git a/chains/atomic/test_shared_memory.go b/chains/atomic/test_shared_memory.go
index 7d3c9ded1a73..d89940c31c2f 100644
--- a/chains/atomic/test_shared_memory.go
+++ b/chains/atomic/test_shared_memory.go
@@ -31,12 +31,10 @@ var SharedMemoryTests = []func(t *testing.T, chainID0, chainID1 ids.ID, sm0, sm1
 func TestSharedMemoryPutAndGet(t *testing.T, chainID0, chainID1 ids.ID, sm0, sm1 SharedMemory, _ database.Database) {
 	require := require.New(t)
 
-	err := sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
+	require.NoError(sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
 		Key:   []byte{0},
 		Value: []byte{1},
-	}}}})
-
-	require.NoError(err)
+	}}}}))
 
 	values, err := sm1.Get(chainID0, [][]byte{{0}})
 	require.NoError(err)
@@ -73,12 +71,11 @@ func TestSharedMemoryLargePutGetAndRemove(t *testing.T, chainID0, chainID1 ids.I
 		keys = append(keys, key)
 	}
 
-	err = sm0.Apply(map[ids.ID]*Requests{
+	require.NoError(sm0.Apply(map[ids.ID]*Requests{
 		chainID1: {
 			PutRequests: elems,
 		},
-	})
-	require.NoError(err)
+	}))
 
 	values, err := sm1.Get(
 		chainID0,
@@ -89,37 +86,33 @@ func TestSharedMemoryLargePutGetAndRemove(t *testing.T, chainID0, chainID1 ids.I
 		require.Equal(elems[i].Value, value)
 	}
 
-	err = sm1.Apply(map[ids.ID]*Requests{
+	require.NoError(sm1.Apply(map[ids.ID]*Requests{
 		chainID0: {
 			RemoveRequests: keys,
 		},
-	})
-
-	require.NoError(err)
+	}))
 }
 
 func TestSharedMemoryIndexed(t *testing.T, chainID0, chainID1 ids.ID, sm0, sm1 SharedMemory, _ database.Database) {
 	require := require.New(t)
 
-	err := sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
+	require.NoError(sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
 		Key:   []byte{0},
 		Value: []byte{1},
 		Traits: [][]byte{
 			{2},
 			{3},
 		},
-	}}}})
-	require.NoError(err)
+	}}}}))
 
-	err = sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
+	require.NoError(sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
 		Key:   []byte{4},
 		Value: []byte{5},
 		Traits: [][]byte{
 			{2},
 			{3},
 		},
-	}}}})
-	require.NoError(err)
+	}}}}))
 
 	values, _, _, err := sm0.Indexed(chainID1, [][]byte{{2}}, nil, nil, 1)
 	require.NoError(err)
@@ -183,8 +176,7 @@ func TestSharedMemoryLargeIndexed(t *testing.T, chainID0, chainID1 ids.ID, sm0,
 		})
 	}
 
-	err = sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: elems}})
-	require.NoError(err)
+	require.NoError(sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: elems}}))
 
 	values, _, _, err := sm1.Indexed(chainID0, allTraits, nil, nil, len(elems)+1)
 	require.NoError(err)
@@ -207,11 +199,10 @@ func TestSharedMemoryCantDuplicatePut(t *testing.T, _, chainID1 ids.ID, sm0, _ S
 	// TODO: require error to be errDuplicatedOperation
 	require.Error(err) //nolint:forbidigo // currently returns grpc errors too
 
-	err = sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
+	require.NoError(sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
 		Key:   []byte{0},
 		Value: []byte{1},
-	}}}})
-	require.NoError(err)
+	}}}}))
 
 	err = sm0.Apply(map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
 		Key:   []byte{0},
@@ -224,10 +215,9 @@ func TestSharedMemoryCantDuplicatePut(t *testing.T, _, chainID1 ids.ID, sm0, _ S
 func TestSharedMemoryCantDuplicateRemove(t *testing.T, _, chainID1 ids.ID, sm0, _ SharedMemory, _ database.Database) {
 	require := require.New(t)
 
-	err := sm0.Apply(map[ids.ID]*Requests{chainID1: {RemoveRequests: [][]byte{{0}}}})
-	require.NoError(err)
+	require.NoError(sm0.Apply(map[ids.ID]*Requests{chainID1: {RemoveRequests: [][]byte{{0}}}}))
 
-	err = sm0.Apply(map[ids.ID]*Requests{chainID1: {RemoveRequests: [][]byte{{0}}}})
+	err := sm0.Apply(map[ids.ID]*Requests{chainID1: {RemoveRequests: [][]byte{{0}}}})
 	// TODO: require error to be errDuplicatedOperation
 	require.Error(err) //nolint:forbidigo // currently returns grpc errors too
 }
@@ -235,25 +225,21 @@ func TestSharedMemoryCantDuplicateRemove(t *testing.T, _, chainID1 ids.ID, sm0,
 func TestSharedMemoryCommitOnPut(t *testing.T, _, chainID1 ids.ID, sm0, _ SharedMemory, db database.Database) {
 	require := require.New(t)
 
-	err := db.Put([]byte{1}, []byte{2})
-	require.NoError(err)
+	require.NoError(db.Put([]byte{1}, []byte{2}))
 
 	batch := db.NewBatch()
 
-	err = batch.Put([]byte{0}, []byte{1})
-	require.NoError(err)
+	require.NoError(batch.Put([]byte{0}, []byte{1}))
 
-	err = batch.Delete([]byte{1})
-	require.NoError(err)
+	require.NoError(batch.Delete([]byte{1}))
 
-	err = sm0.Apply(
+	require.NoError(sm0.Apply(
 		map[ids.ID]*Requests{chainID1: {PutRequests: []*Element{{
 			Key:   []byte{0},
 			Value: []byte{1},
 		}}}},
 		batch,
-	)
-	require.NoError(err)
+	))
 
 	val, err := db.Get([]byte{0})
 	require.NoError(err)
@@ -267,22 +253,18 @@ func TestSharedMemoryCommitOnPut(t *testing.T, _, chainID1 ids.ID, sm0, _ Shared
 func TestSharedMemoryCommitOnRemove(t *testing.T, _, chainID1 ids.ID, sm0, _ SharedMemory, db database.Database) {
 	require := require.New(t)
 
-	err := db.Put([]byte{1}, []byte{2})
-	require.NoError(err)
+	require.NoError(db.Put([]byte{1}, []byte{2}))
 
 	batch := db.NewBatch()
 
-	err = batch.Put([]byte{0}, []byte{1})
-	require.NoError(err)
+	require.NoError(batch.Put([]byte{0}, []byte{1}))
 
-	err = batch.Delete([]byte{1})
-	require.NoError(err)
+	require.NoError(batch.Delete([]byte{1}))
 
-	err = sm0.Apply(
+	require.NoError(sm0.Apply(
 		map[ids.ID]*Requests{chainID1: {RemoveRequests: [][]byte{{0}}}},
 		batch,
-	)
-	require.NoError(err)
+	))
 
 	val, err := db.Get([]byte{0})
 	require.NoError(err)
@@ -299,8 +281,7 @@ func TestPutAndRemoveBatch(t *testing.T, chainID0, _ ids.ID, _, sm1 SharedMemory
 
 	batch := db.NewBatch()
 
-	err := batch.Put([]byte{0}, []byte{1})
-	require.NoError(err)
+	require.NoError(batch.Put([]byte{0}, []byte{1}))
 
 	batchChainsAndInputs := make(map[ids.ID]*Requests)
 
@@ -314,9 +295,7 @@ func TestPutAndRemoveBatch(t *testing.T, chainID0, _ ids.ID, _, sm1 SharedMemory
 		RemoveRequests: byteArr,
 	}
 
-	err = sm1.Apply(batchChainsAndInputs, batch)
-
-	require.NoError(err)
+	require.NoError(sm1.Apply(batchChainsAndInputs, batch))
 
 	val, err := db.Get([]byte{0})
 	require.NoError(err)
@@ -348,24 +327,19 @@ func TestSharedMemoryLargeBatchSize(t *testing.T, _, chainID1 ids.ID, sm0, _ Sha
 		value := bytes[:elementSize]
 		bytes = bytes[elementSize:]
 
-		err := batch.Put(key, value)
-		require.NoError(err)
+		require.NoError(batch.Put(key, value))
 	}
 
-	err = db.Put([]byte{1}, []byte{2})
-	require.NoError(err)
+	require.NoError(db.Put([]byte{1}, []byte{2}))
 
-	err = batch.Put([]byte{0}, []byte{1})
-	require.NoError(err)
+	require.NoError(batch.Put([]byte{0}, []byte{1}))
 
-	err = batch.Delete([]byte{1})
-	require.NoError(err)
+	require.NoError(batch.Delete([]byte{1}))
 
-	err = sm0.Apply(
+	require.NoError(sm0.Apply(
 		map[ids.ID]*Requests{chainID1: {RemoveRequests: [][]byte{{0}}}},
 		batch,
-	)
-	require.NoError(err)
+	))
 
 	val, err := db.Get([]byte{0})
 	require.NoError(err)
@@ -382,16 +356,13 @@ func TestSharedMemoryLargeBatchSize(t *testing.T, _, chainID1 ids.ID, sm0, _ Sha
 		key := bytes[:elementSize]
 		bytes = bytes[pairSize:]
 
-		err := batch.Delete(key)
-		require.NoError(err)
+		require.NoError(batch.Delete(key))
 	}
 
-	err = sm0.Apply(
+	require.NoError(sm0.Apply(
 		map[ids.ID]*Requests{chainID1: {RemoveRequests: [][]byte{{1}}}},
 		batch,
-	)
-
-	require.NoError(err)
+	))
 
 	batch.Reset()
 
@@ -400,8 +371,7 @@ func TestSharedMemoryLargeBatchSize(t *testing.T, _, chainID1 ids.ID, sm0, _ Sha
 		key := bytes[:elementSize]
 		bytes = bytes[pairSize:]
 
-		err := batch.Delete(key)
-		require.NoError(err)
+		require.NoError(batch.Delete(key))
 	}
 
 	batchChainsAndInputs := make(map[ids.ID]*Requests)
@@ -416,9 +386,8 @@ func TestSharedMemoryLargeBatchSize(t *testing.T, _, chainID1 ids.ID, sm0, _ Sha
 		RemoveRequests: byteArr,
 	}
 
-	err = sm0.Apply(
+	require.NoError(sm0.Apply(
 		batchChainsAndInputs,
 		batch,
-	)
-	require.NoError(err)
+	))
 }
diff --git a/codec/test_codec.go b/codec/test_codec.go
index 40e91b7df5a6..13d81d1eca60 100644
--- a/codec/test_codec.go
+++ b/codec/test_codec.go
@@ -167,8 +167,7 @@ func TestUInt32(codec GeneralCodec, t testing.TB) {
 	number := uint32(500)
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, number)
 	require.NoError(err)
@@ -189,11 +188,10 @@ func TestUIntPtr(codec GeneralCodec, t testing.TB) {
 
 	manager := NewDefaultManager()
 
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	number := uintptr(500)
-	_, err = manager.Marshal(0, number)
+	_, err := manager.Marshal(0, number)
 	require.ErrorIs(err, ErrUnsupportedType)
 }
 
@@ -202,8 +200,7 @@ func TestSlice(codec GeneralCodec, t testing.TB) {
 
 	mySlice := []bool{true, false, true, true}
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, mySlice)
 	require.NoError(err)
@@ -227,8 +224,7 @@ func TestMaxSizeSlice(codec GeneralCodec, t testing.TB) {
 	mySlice[0] = "first!"
 	mySlice[math.MaxUint16-1] = "last!"
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, mySlice)
 	require.NoError(err)
@@ -250,8 +246,7 @@ func TestBool(codec GeneralCodec, t testing.TB) {
 
 	myBool := true
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, myBool)
 	require.NoError(err)
@@ -273,8 +268,7 @@ func TestArray(codec GeneralCodec, t testing.TB) {
 
 	myArr := [5]uint64{5, 6, 7, 8, 9}
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, myArr)
 	require.NoError(err)
@@ -296,8 +290,7 @@ func TestBigArray(codec GeneralCodec, t testing.TB) {
 
 	myArr := [30000]uint64{5, 6, 7, 8, 9}
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, myArr)
 	require.NoError(err)
@@ -319,8 +312,7 @@ func TestPointerToStruct(codec GeneralCodec, t testing.TB) {
 
 	myPtr := &MyInnerStruct{Str: "Hello!"}
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, myPtr)
 	require.NoError(err)
@@ -352,12 +344,10 @@ func TestSliceOfStruct(codec GeneralCodec, t testing.TB) {
 			F:   &MyInnerStruct{"Six"},
 		},
 	}
-	err := codec.RegisterType(&MyInnerStruct{})
-	require.NoError(err)
+	require.NoError(codec.RegisterType(&MyInnerStruct{}))
 
 	manager := NewDefaultManager()
-	err = manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, mySlice)
 	require.NoError(err)
@@ -377,12 +367,10 @@ func TestSliceOfStruct(codec GeneralCodec, t testing.TB) {
 func TestInterface(codec GeneralCodec, t testing.TB) {
 	require := require.New(t)
 
-	err := codec.RegisterType(&MyInnerStruct2{})
-	require.NoError(err)
+	require.NoError(codec.RegisterType(&MyInnerStruct2{}))
 
 	manager := NewDefaultManager()
-	err = manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	var f Foo = &MyInnerStruct2{true}
 	bytes, err := manager.Marshal(0, &f)
@@ -411,12 +399,10 @@ func TestSliceOfInterface(codec GeneralCodec, t testing.TB) {
 			Str: ", World!",
 		},
 	}
-	err := codec.RegisterType(&MyInnerStruct{})
-	require.NoError(err)
+	require.NoError(codec.RegisterType(&MyInnerStruct{}))
 
 	manager := NewDefaultManager()
-	err = manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, mySlice)
 	require.NoError(err)
@@ -444,12 +430,10 @@ func TestArrayOfInterface(codec GeneralCodec, t testing.TB) {
 			Str: ", World!",
 		},
 	}
-	err := codec.RegisterType(&MyInnerStruct{})
-	require.NoError(err)
+	require.NoError(codec.RegisterType(&MyInnerStruct{}))
 
 	manager := NewDefaultManager()
-	err = manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, myArray)
 	require.NoError(err)
@@ -472,12 +456,10 @@ func TestPointerToInterface(codec GeneralCodec, t testing.TB) {
 	var myinnerStruct Foo = &MyInnerStruct{Str: "Hello!"}
 	myPtr := &myinnerStruct
 
-	err := codec.RegisterType(&MyInnerStruct{})
-	require.NoError(err)
+	require.NoError(codec.RegisterType(&MyInnerStruct{}))
 
 	manager := NewDefaultManager()
-	err = manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, &myPtr)
 	require.NoError(err)
@@ -499,8 +481,7 @@ func TestString(codec GeneralCodec, t testing.TB) {
 
 	myString := "Ayy"
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, myString)
 	require.NoError(err)
@@ -526,8 +507,7 @@ func TestNilSlice(codec GeneralCodec, t testing.TB) {
 
 	myStruct := structWithSlice{Slice: nil}
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	bytes, err := manager.Marshal(0, myStruct)
 	require.NoError(err)
@@ -559,10 +539,9 @@ func TestSerializeUnexportedField(codec GeneralCodec, t testing.TB) {
 	}
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
-	_, err = manager.Marshal(0, myS)
+	_, err := manager.Marshal(0, myS)
 	require.ErrorIs(err, ErrUnexportedField)
 
 	_, err = manager.Size(0, myS)
@@ -583,8 +562,7 @@ func TestSerializeOfNoSerializeField(codec GeneralCodec, t testing.TB) {
 		UnmarkedField:     "No declared serialize",
 	}
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	marshalled, err := manager.Marshal(0, myS)
 	require.NoError(err)
@@ -611,8 +589,7 @@ func TestNilSliceSerialization(codec GeneralCodec, t testing.TB) {
 	}
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	val := &simpleSliceStruct{}
 	expected := []byte{0, 0, 0, 0, 0, 0} // 0 for codec version, then nil slice marshaled as 0 length slice
@@ -640,8 +617,7 @@ func TestEmptySliceSerialization(codec GeneralCodec, t testing.TB) {
 	}
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	val := &simpleSliceStruct{Arr: make([]uint32, 0, 1)}
 	expected := []byte{0, 0, 0, 0, 0, 0} // 0 for codec version (uint16) and 0 for size (uint32)
@@ -671,8 +647,7 @@ func TestSliceWithEmptySerialization(codec GeneralCodec, t testing.TB) {
 	}
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	val := &nestedSliceStruct{
 		Arr: make([]emptyStruct, 1000),
@@ -703,13 +678,12 @@ func TestSliceWithEmptySerializationOutOfMemory(codec GeneralCodec, t testing.TB
 	}
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	val := &nestedSliceStruct{
 		Arr: make([]emptyStruct, math.MaxInt32),
 	}
-	_, err = manager.Marshal(0, val)
+	_, err := manager.Marshal(0, val)
 	require.ErrorIs(err, ErrMaxSliceLenExceeded)
 
 	bytesLen, err := manager.Size(0, val)
@@ -721,12 +695,11 @@ func TestSliceTooLarge(codec GeneralCodec, t testing.TB) {
 	require := require.New(t)
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	val := []struct{}{}
 	b := []byte{0x00, 0x00, 0xff, 0xff, 0xff, 0xff}
-	_, err = manager.Unmarshal(b, &val)
+	_, err := manager.Unmarshal(b, &val)
 	require.ErrorIs(err, ErrMaxSliceLenExceeded)
 }
 
@@ -742,8 +715,7 @@ func TestNegativeNumbers(codec GeneralCodec, t testing.TB) {
 	}
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	myS := s{-1, -2, -3, -4}
 	bytes, err := manager.Marshal(0, myS)
@@ -770,11 +742,10 @@ func TestTooLargeUnmarshal(codec GeneralCodec, t testing.TB) {
 	bytes := []byte{0, 0, 0, 0}
 
 	manager := NewManager(3)
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	s := inner{}
-	_, err = manager.Unmarshal(bytes, &s)
+	_, err := manager.Unmarshal(bytes, &s)
 	require.ErrorIs(err, errUnmarshalTooBig)
 }
 
@@ -828,11 +799,10 @@ func TestRestrictedSlice(codec GeneralCodec, t testing.TB) {
 	bytes := []byte{0, 0, 0, 0, 0, 3, 0, 1, 2}
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	s := inner{}
-	_, err = manager.Unmarshal(bytes, &s)
+	_, err := manager.Unmarshal(bytes, &s)
 	require.ErrorIs(err, ErrMaxSliceLenExceeded)
 
 	s.Bytes = []byte{0, 1, 2}
@@ -845,13 +815,12 @@ func TestExtraSpace(codec GeneralCodec, t testing.TB) {
 	require := require.New(t)
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	// codec version 0x0000 then 0x01 for b then 0x02 as extra data.
 	byteSlice := []byte{0x00, 0x00, 0x01, 0x02}
 	var b byte
-	_, err = manager.Unmarshal(byteSlice, &b)
+	_, err := manager.Unmarshal(byteSlice, &b)
 	require.ErrorIs(err, ErrExtraSpace)
 }
 
@@ -870,11 +839,10 @@ func TestSliceLengthOverflow(codec GeneralCodec, t testing.TB) {
 	}
 
 	manager := NewDefaultManager()
-	err := manager.RegisterCodec(0, codec)
-	require.NoError(err)
+	require.NoError(manager.RegisterCodec(0, codec))
 
 	s := inner{}
-	_, err = manager.Unmarshal(bytes, &s)
+	_, err := manager.Unmarshal(bytes, &s)
 	require.ErrorIs(err, ErrMaxSliceLenExceeded)
 }
 
@@ -902,8 +870,7 @@ func TestMultipleTags(codec GeneralCodec, t testing.TB) {
 	for _, codecVersion := range []uint16{0, 1, 2022} {
 		require := require.New(t)
 
-		err := manager.RegisterCodec(codecVersion, codec)
-		require.NoError(err)
+		require.NoError(manager.RegisterCodec(codecVersion, codec))
 
 		bytes, err := manager.Marshal(codecVersion, inputs)
 		require.NoError(err)
diff --git a/database/corruptabledb/db_test.go b/database/corruptabledb/db_test.go
index 6c05036e9c6a..6e0aff1785a9 100644
--- a/database/corruptabledb/db_test.go
+++ b/database/corruptabledb/db_test.go
@@ -55,8 +55,7 @@ func TestCorruption(t *testing.T) {
 			corruptableBatch := db.NewBatch()
 			require.NotNil(t, corruptableBatch)
 
-			err := corruptableBatch.Put(key, value)
-			require.NoError(t, err)
+			require.NoError(t, corruptableBatch.Put(key, value))
 
 			return corruptableBatch.Write()
 		},
diff --git a/database/linkeddb/linkeddb_test.go b/database/linkeddb/linkeddb_test.go
index 9ee698dcb234..c7b24693eaa4 100644
--- a/database/linkeddb/linkeddb_test.go
+++ b/database/linkeddb/linkeddb_test.go
@@ -28,11 +28,9 @@ func TestLinkedDB(t *testing.T) {
 	_, err = ldb.Get(key)
 	require.Equal(database.ErrNotFound, err, "Expected db.Get to return a Not Found error.")
 
-	err = ldb.Delete(key)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key))
 
-	err = ldb.Put(key, value)
-	require.NoError(err)
+	require.NoError(ldb.Put(key, value))
 
 	has, err = ldb.Has(key)
 	require.NoError(err)
@@ -42,8 +40,7 @@ func TestLinkedDB(t *testing.T) {
 	require.NoError(err)
 	require.Equal(value, v)
 
-	err = ldb.Delete(key)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key))
 
 	has, err = ldb.Has(key)
 	require.NoError(err)
@@ -68,18 +65,15 @@ func TestLinkedDBDuplicatedPut(t *testing.T) {
 	value1 := []byte("world1")
 	value2 := []byte("world2")
 
-	err := ldb.Put(key, value1)
-	require.NoError(err)
+	require.NoError(ldb.Put(key, value1))
 
-	err = ldb.Put(key, value2)
-	require.NoError(err)
+	require.NoError(ldb.Put(key, value2))
 
 	v, err := ldb.Get(key)
 	require.NoError(err)
 	require.Equal(value2, v)
 
-	err = ldb.Delete(key)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key))
 
 	iterator := db.NewIterator()
 	next := iterator.Next()
@@ -100,11 +94,9 @@ func TestLinkedDBMultiplePuts(t *testing.T) {
 	value2 := []byte("world2")
 	value3 := []byte("world3")
 
-	err := ldb.Put(key1, value1)
-	require.NoError(err)
+	require.NoError(ldb.Put(key1, value1))
 
-	err = ldb.Put(key2, value2)
-	require.NoError(err)
+	require.NoError(ldb.Put(key2, value2))
 
 	v, err := ldb.Get(key1)
 	require.NoError(err)
@@ -114,23 +106,17 @@ func TestLinkedDBMultiplePuts(t *testing.T) {
 	require.NoError(err)
 	require.Equal(value2, v)
 
-	err = ldb.Delete(key2)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key2))
 
-	err = ldb.Put(key2, value2)
-	require.NoError(err)
+	require.NoError(ldb.Put(key2, value2))
 
-	err = ldb.Put(key3, value3)
-	require.NoError(err)
+	require.NoError(ldb.Put(key3, value3))
 
-	err = ldb.Delete(key2)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key2))
 
-	err = ldb.Delete(key1)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key1))
 
-	err = ldb.Delete(key3)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key3))
 
 	iterator := db.NewIterator()
 	next := iterator.Next()
@@ -154,8 +140,7 @@ func TestEmptyLinkedDBIterator(t *testing.T) {
 	v := iterator.Value()
 	require.Nil(v, "The iterator returned the wrong value")
 
-	err := iterator.Error()
-	require.NoError(err)
+	require.NoError(iterator.Error())
 
 	iterator.Release()
 }
@@ -169,8 +154,7 @@ func TestLinkedDBLoadHeadKey(t *testing.T) {
 	key := []byte("hello")
 	value := []byte("world")
 
-	err := ldb.Put(key, value)
-	require.NoError(err)
+	require.NoError(ldb.Put(key, value))
 
 	ldb = NewDefault(db)
 
@@ -193,8 +177,7 @@ func TestLinkedDBLoadHeadKey(t *testing.T) {
 	v = iterator.Value()
 	require.Nil(v, "The iterator returned the wrong value")
 
-	err = iterator.Error()
-	require.NoError(err)
+	require.NoError(iterator.Error())
 
 	iterator.Release()
 }
@@ -208,8 +191,7 @@ func TestSingleLinkedDBIterator(t *testing.T) {
 	key := []byte("hello")
 	value := []byte("world")
 
-	err := ldb.Put(key, value)
-	require.NoError(err)
+	require.NoError(ldb.Put(key, value))
 
 	iterator := ldb.NewIterator()
 	next := iterator.Next()
@@ -230,8 +212,7 @@ func TestSingleLinkedDBIterator(t *testing.T) {
 	v = iterator.Value()
 	require.Nil(v, "The iterator returned the wrong value")
 
-	err = iterator.Error()
-	require.NoError(err)
+	require.NoError(iterator.Error())
 
 	iterator.Release()
 }
@@ -247,11 +228,9 @@ func TestMultipleLinkedDBIterator(t *testing.T) {
 	value0 := []byte("world0")
 	value1 := []byte("world1")
 
-	err := ldb.Put(key0, value0)
-	require.NoError(err)
+	require.NoError(ldb.Put(key0, value0))
 
-	err = ldb.Put(key1, value1)
-	require.NoError(err)
+	require.NoError(ldb.Put(key1, value1))
 
 	iterator := ldb.NewIterator()
 	next := iterator.Next()
@@ -275,8 +254,7 @@ func TestMultipleLinkedDBIterator(t *testing.T) {
 	next = iterator.Next()
 	require.False(next, "The iterator should now be exhausted")
 
-	err = iterator.Error()
-	require.NoError(err)
+	require.NoError(iterator.Error())
 
 	iterator.Release()
 }
@@ -292,11 +270,9 @@ func TestMultipleLinkedDBIteratorStart(t *testing.T) {
 	value0 := []byte("world0")
 	value1 := []byte("world1")
 
-	err := ldb.Put(key0, value0)
-	require.NoError(err)
+	require.NoError(ldb.Put(key0, value0))
 
-	err = ldb.Put(key1, value1)
-	require.NoError(err)
+	require.NoError(ldb.Put(key1, value1))
 
 	iterator := ldb.NewIteratorWithStart(key1)
 	next := iterator.Next()
@@ -320,8 +296,7 @@ func TestMultipleLinkedDBIteratorStart(t *testing.T) {
 	next = iterator.Next()
 	require.False(next, "The iterator should now be exhausted")
 
-	err = iterator.Error()
-	require.NoError(err)
+	require.NoError(iterator.Error())
 
 	iterator.Release()
 }
@@ -337,11 +312,9 @@ func TestSingleLinkedDBIteratorStart(t *testing.T) {
 	value0 := []byte("world0")
 	value1 := []byte("world1")
 
-	err := ldb.Put(key0, value0)
-	require.NoError(err)
+	require.NoError(ldb.Put(key0, value0))
 
-	err = ldb.Put(key1, value1)
-	require.NoError(err)
+	require.NoError(ldb.Put(key1, value1))
 
 	iterator := ldb.NewIteratorWithStart(key0)
 
@@ -357,8 +330,7 @@ func TestSingleLinkedDBIteratorStart(t *testing.T) {
 	next = iterator.Next()
 	require.False(next, "The iterator should now be exhausted")
 
-	err = iterator.Error()
-	require.NoError(err)
+	require.NoError(iterator.Error())
 
 	iterator.Release()
 }
@@ -377,11 +349,9 @@ func TestEmptyLinkedDBIteratorStart(t *testing.T) {
 	value0 := []byte("world0")
 	value1 := []byte("world1")
 
-	err := ldb.Put(key0, value0)
-	require.NoError(err)
+	require.NoError(ldb.Put(key0, value0))
 
-	err = ldb.Put(key1, value1)
-	require.NoError(err)
+	require.NoError(ldb.Put(key1, value1))
 
 	iter := ldb.NewIteratorWithStart(key2)
 
@@ -393,8 +363,7 @@ func TestEmptyLinkedDBIteratorStart(t *testing.T) {
 	}
 	require.Equal(2, i)
 
-	err = iter.Error()
-	require.NoError(err)
+	require.NoError(iter.Error())
 
 	iter.Release()
 }
@@ -412,15 +381,13 @@ func TestLinkedDBIsEmpty(t *testing.T) {
 	key := []byte("hello")
 	value := []byte("world")
 
-	err = ldb.Put(key, value)
-	require.NoError(err)
+	require.NoError(ldb.Put(key, value))
 
 	isEmpty, err = ldb.IsEmpty()
 	require.NoError(err)
 	require.False(isEmpty)
 
-	err = ldb.Delete(key)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key))
 
 	isEmpty, err = ldb.IsEmpty()
 	require.NoError(err)
@@ -441,22 +408,19 @@ func TestLinkedDBHeadKey(t *testing.T) {
 	key1 := []byte("hello1")
 	value1 := []byte("world1")
 
-	err = ldb.Put(key0, value0)
-	require.NoError(err)
+	require.NoError(ldb.Put(key0, value0))
 
 	headKey, err := ldb.HeadKey()
 	require.NoError(err)
 	require.Equal(key0, headKey)
 
-	err = ldb.Put(key1, value1)
-	require.NoError(err)
+	require.NoError(ldb.Put(key1, value1))
 
 	headKey, err = ldb.HeadKey()
 	require.NoError(err)
 	require.Equal(key1, headKey)
 
-	err = ldb.Delete(key1)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key1))
 
 	headKey, err = ldb.HeadKey()
 	require.NoError(err)
@@ -477,24 +441,21 @@ func TestLinkedDBHead(t *testing.T) {
 	key1 := []byte("hello1")
 	value1 := []byte("world1")
 
-	err = ldb.Put(key0, value0)
-	require.NoError(err)
+	require.NoError(ldb.Put(key0, value0))
 
 	headKey, headVal, err := ldb.Head()
 	require.NoError(err)
 	require.Equal(key0, headKey)
 	require.Equal(value0, headVal)
 
-	err = ldb.Put(key1, value1)
-	require.NoError(err)
+	require.NoError(ldb.Put(key1, value1))
 
 	headKey, headVal, err = ldb.Head()
 	require.NoError(err)
 	require.Equal(key1, headKey)
 	require.Equal(value1, headVal)
 
-	err = ldb.Delete(key1)
-	require.NoError(err)
+	require.NoError(ldb.Delete(key1))
 
 	headKey, headVal, err = ldb.Head()
 	require.NoError(err)
diff --git a/database/manager/manager_test.go b/database/manager/manager_test.go
index d4ca0c45e423..2e309fcc2782 100644
--- a/database/manager/manager_test.go
+++ b/database/manager/manager_test.go
@@ -31,8 +31,7 @@ func TestNewSingleLevelDB(t *testing.T) {
 	db, err := leveldb.New(dbPath, nil, logging.NoLog{}, "", prometheus.NewRegistry())
 	require.NoError(err)
 
-	err = db.Close()
-	require.NoError(err)
+	require.NoError(db.Close())
 
 	manager, err := NewLevelDB(dir, nil, logging.NoLog{}, v1, "", prometheus.NewRegistry())
 	require.NoError(err)
@@ -47,8 +46,7 @@ func TestNewSingleLevelDB(t *testing.T) {
 	dbs := manager.GetDatabases()
 	require.Len(dbs, 1)
 
-	err = manager.Close()
-	require.NoError(err)
+	require.NoError(manager.Close())
 }
 
 func TestNewCreatesSingleDB(t *testing.T) {
@@ -71,8 +69,7 @@ func TestNewCreatesSingleDB(t *testing.T) {
 	dbs := manager.GetDatabases()
 	require.Len(dbs, 1)
 
-	err = manager.Close()
-	require.NoError(err)
+	require.NoError(manager.Close())
 }
 
 func TestNewInvalidMemberPresent(t *testing.T) {
@@ -99,26 +96,22 @@ func TestNewInvalidMemberPresent(t *testing.T) {
 	db2, err := leveldb.New(dbPath2, nil, logging.NoLog{}, "", prometheus.NewRegistry())
 	require.NoError(err)
 
-	err = db2.Close()
-	require.NoError(err)
+	require.NoError(db2.Close())
 
 	_, err = NewLevelDB(dir, nil, logging.NoLog{}, v2, "", prometheus.NewRegistry())
 	require.ErrorIs(err, leveldb.ErrCouldNotOpen)
 
-	err = db1.Close()
-	require.NoError(err)
+	require.NoError(db1.Close())
 
 	f, err := os.Create(filepath.Join(dir, "dummy"))
 	require.NoError(err)
 
-	err = f.Close()
-	require.NoError(err)
+	require.NoError(f.Close())
 
 	db, err := NewLevelDB(dir, nil, logging.NoLog{}, v1, "", prometheus.NewRegistry())
 	require.NoError(err, "expected not to error with a non-directory file being present")
 
-	err = db.Close()
-	require.NoError(err)
+	require.NoError(db.Close())
 }
 
 func TestNewSortsDatabases(t *testing.T) {
@@ -159,8 +152,7 @@ func TestNewSortsDatabases(t *testing.T) {
 		db, err := leveldb.New(dbPath, nil, logging.NoLog{}, "", prometheus.NewRegistry())
 		require.NoError(err)
 
-		err = db.Close()
-		require.NoError(err)
+		require.NoError(db.Close())
 	}
 
 	manager, err := NewLevelDB(dir, nil, logging.NoLog{}, vers[0], "", prometheus.NewRegistry())
diff --git a/ids/aliases_test.go b/ids/aliases_test.go
index 624d40eb1393..2e50b992aaf2 100644
--- a/ids/aliases_test.go
+++ b/ids/aliases_test.go
@@ -22,17 +22,14 @@ func TestPrimaryAliasOrDefaultTest(t *testing.T) {
 	aliaser := NewAliaser()
 	id1 := ID{'J', 'a', 'm', 'e', 's', ' ', 'G', 'o', 'r', 'd', 'o', 'n'}
 	id2 := ID{'B', 'r', 'u', 'c', 'e', ' ', 'W', 'a', 'y', 'n', 'e'}
-	err := aliaser.Alias(id2, "Batman")
-	require.NoError(err)
+	require.NoError(aliaser.Alias(id2, "Batman"))
 
-	err = aliaser.Alias(id2, "Dark Knight")
-	require.NoError(err)
+	require.NoError(aliaser.Alias(id2, "Dark Knight"))
 
 	res := aliaser.PrimaryAliasOrDefault(id1)
 	require.Equal(res, id1.String())
 
 	expected := "Batman"
 	res = aliaser.PrimaryAliasOrDefault(id2)
-	require.NoError(err)
 	require.Equal(expected, res)
 }
diff --git a/ids/test_aliases.go b/ids/test_aliases.go
index 04d5e5d139c5..5a0299720015 100644
--- a/ids/test_aliases.go
+++ b/ids/test_aliases.go
@@ -23,8 +23,7 @@ func AliaserLookupErrorTest(require *require.Assertions, r AliaserReader, _ Alia
 
 func AliaserLookupTest(require *require.Assertions, r AliaserReader, w AliaserWriter) {
 	id := ID{'K', 'a', 't', 'e', ' ', 'K', 'a', 'n', 'e'}
-	err := w.Alias(id, "Batwoman")
-	require.NoError(err)
+	require.NoError(w.Alias(id, "Batwoman"))
 
 	res, err := r.Lookup("Batwoman")
 	require.NoError(err)
@@ -41,11 +40,9 @@ func AliaserAliasesEmptyTest(require *require.Assertions, r AliaserReader, _ Ali
 
 func AliaserAliasesTest(require *require.Assertions, r AliaserReader, w AliaserWriter) {
 	id := ID{'B', 'r', 'u', 'c', 'e', ' ', 'W', 'a', 'y', 'n', 'e'}
-	err := w.Alias(id, "Batman")
-	require.NoError(err)
+	require.NoError(w.Alias(id, "Batman"))
 
-	err = w.Alias(id, "Dark Knight")
-	require.NoError(err)
+	require.NoError(w.Alias(id, "Dark Knight"))
 
 	aliases, err := r.Aliases(id)
 	require.NoError(err)
@@ -57,13 +54,11 @@ func AliaserAliasesTest(require *require.Assertions, r AliaserReader, w AliaserW
 func AliaserPrimaryAliasTest(require *require.Assertions, r AliaserReader, w AliaserWriter) {
 	id1 := ID{'J', 'a', 'm', 'e', 's', ' ', 'G', 'o', 'r', 'd', 'o', 'n'}
 	id2 := ID{'B', 'r', 'u', 'c', 'e', ' ', 'W', 'a', 'y', 'n', 'e'}
-	err := w.Alias(id2, "Batman")
-	require.NoError(err)
+	require.NoError(w.Alias(id2, "Batman"))
 
-	err = w.Alias(id2, "Dark Knight")
-	require.NoError(err)
+	require.NoError(w.Alias(id2, "Dark Knight"))
 
-	_, err = r.PrimaryAlias(id1)
+	_, err := r.PrimaryAlias(id1)
 	// TODO: require error to be errNoAliasForID
 	require.Error(err) //nolint:forbidigo // currently returns grpc errors too
 
@@ -76,10 +71,9 @@ func AliaserPrimaryAliasTest(require *require.Assertions, r AliaserReader, w Ali
 func AliaserAliasClashTest(require *require.Assertions, _ AliaserReader, w AliaserWriter) {
 	id1 := ID{'B', 'r', 'u', 'c', 'e', ' ', 'W', 'a', 'y', 'n', 'e'}
 	id2 := ID{'D', 'i', 'c', 'k', ' ', 'G', 'r', 'a', 'y', 's', 'o', 'n'}
-	err := w.Alias(id1, "Batman")
-	require.NoError(err)
+	require.NoError(w.Alias(id1, "Batman"))
 
-	err = w.Alias(id2, "Batman")
+	err := w.Alias(id2, "Batman")
 	// TODO: require error to be errAliasAlreadyMapped
 	require.Error(err) //nolint:forbidigo // currently returns grpc errors too
 }
@@ -87,24 +81,19 @@ func AliaserAliasClashTest(require *require.Assertions, _ AliaserReader, w Alias
 func AliaserRemoveAliasTest(require *require.Assertions, r AliaserReader, w AliaserWriter) {
 	id1 := ID{'B', 'r', 'u', 'c', 'e', ' ', 'W', 'a', 'y', 'n', 'e'}
 	id2 := ID{'J', 'a', 'm', 'e', 's', ' ', 'G', 'o', 'r', 'd', 'o', 'n'}
-	err := w.Alias(id1, "Batman")
-	require.NoError(err)
+	require.NoError(w.Alias(id1, "Batman"))
 
-	err = w.Alias(id1, "Dark Knight")
-	require.NoError(err)
+	require.NoError(w.Alias(id1, "Dark Knight"))
 
 	w.RemoveAliases(id1)
 
-	_, err = r.PrimaryAlias(id1)
+	_, err := r.PrimaryAlias(id1)
 	// TODO: require error to be errNoAliasForID
 	require.Error(err) //nolint:forbidigo // currently returns grpc errors too
 
-	err = w.Alias(id2, "Batman")
-	require.NoError(err)
+	require.NoError(w.Alias(id2, "Batman"))
 
-	err = w.Alias(id2, "Dark Knight")
-	require.NoError(err)
+	require.NoError(w.Alias(id2, "Dark Knight"))
 
-	err = w.Alias(id1, "Dark Night Rises")
-	require.NoError(err)
+	require.NoError(w.Alias(id1, "Dark Night Rises"))
 }
diff --git a/indexer/index_test.go b/indexer/index_test.go
index 9a25bebcc8e1..760700ab05f3 100644
--- a/indexer/index_test.go
+++ b/indexer/index_test.go
@@ -25,8 +25,7 @@ func TestIndex(t *testing.T) {
 	pageSize := uint64(64)
 	require := require.New(t)
 	codec := codec.NewDefaultManager()
-	err := codec.RegisterCodec(codecVersion, linearcodec.NewDefault())
-	require.NoError(err)
+	require.NoError(codec.RegisterCodec(codecVersion, linearcodec.NewDefault()))
 	baseDB := memdb.New()
 	db := versiondb.New(baseDB)
 	ctx := snow.DefaultConsensusContextTest()
@@ -44,8 +43,7 @@ func TestIndex(t *testing.T) {
 	// Accept each container and after each, make assertions
 	i := uint64(0)
 	for containerID, containerBytes := range containers {
-		err = idx.Accept(ctx, containerID, containerBytes)
-		require.NoError(err)
+		require.NoError(idx.Accept(ctx, containerID, containerBytes))
 
 		lastAcceptedIndex, ok := idx.lastAcceptedIndex()
 		require.True(ok)
@@ -116,8 +114,7 @@ func TestIndexGetContainerByRangeMaxPageSize(t *testing.T) {
 	// Setup
 	require := require.New(t)
 	codec := codec.NewDefaultManager()
-	err := codec.RegisterCodec(codecVersion, linearcodec.NewDefault())
-	require.NoError(err)
+	require.NoError(codec.RegisterCodec(codecVersion, linearcodec.NewDefault()))
 	db := memdb.New()
 	ctx := snow.DefaultConsensusContextTest()
 	indexIntf, err := newIndex(db, logging.NoLog{}, codec, mockable.Clock{})
@@ -126,8 +123,7 @@ func TestIndexGetContainerByRangeMaxPageSize(t *testing.T) {
 
 	// Insert [MaxFetchedByRange] + 1 containers
 	for i := uint64(0); i < MaxFetchedByRange+1; i++ {
-		err = idx.Accept(ctx, ids.GenerateTestID(), utils.RandomBytes(32))
-		require.NoError(err)
+		require.NoError(idx.Accept(ctx, ids.GenerateTestID(), utils.RandomBytes(32)))
 	}
 
 	// Page size too large
@@ -158,8 +154,7 @@ func TestDontIndexSameContainerTwice(t *testing.T) {
 	// Setup
 	require := require.New(t)
 	codec := codec.NewDefaultManager()
-	err := codec.RegisterCodec(codecVersion, linearcodec.NewDefault())
-	require.NoError(err)
+	require.NoError(codec.RegisterCodec(codecVersion, linearcodec.NewDefault()))
 	db := memdb.New()
 	ctx := snow.DefaultConsensusContextTest()
 	idx, err := newIndex(db, logging.NoLog{}, codec, mockable.Clock{})
diff --git a/message/messages_benchmark_test.go b/message/messages_benchmark_test.go
index f87493fc0248..8d0939a67348 100644
--- a/message/messages_benchmark_test.go
+++ b/message/messages_benchmark_test.go
@@ -128,10 +128,10 @@ func BenchmarkUnmarshalVersion(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		if useBuilder {
 			_, err = codec.parseInbound(rawMsg, dummyNodeID, dummyOnFinishedHandling)
+			require.NoError(err)
 		} else {
 			var msg p2p.Message
-			err = proto.Unmarshal(rawMsg, &msg)
+			require.NoError(proto.Unmarshal(rawMsg, &msg))
 		}
-		require.NoError(err)
 	}
 }
diff --git a/network/network_test.go b/network/network_test.go
index 0afab859d80d..ac4c98e1768e 100644
--- a/network/network_test.go
+++ b/network/network_test.go
@@ -222,14 +222,12 @@ func newFullyConnectedTestNetwork(t *testing.T, handlers []router.InboundHandler
 		}
 
 		beacons := validators.NewSet()
-		err = beacons.Add(nodeIDs[0], nil, ids.GenerateTestID(), 1)
-		require.NoError(err)
+		require.NoError(beacons.Add(nodeIDs[0], nil, ids.GenerateTestID(), 1))
 
 		primaryVdrs := validators.NewSet()
 		primaryVdrs.RegisterCallbackListener(&gossipTrackerCallback)
 		for _, nodeID := range nodeIDs {
-			err := primaryVdrs.Add(nodeID, nil, ids.GenerateTestID(), 1)
-			require.NoError(err)
+			require.NoError(primaryVdrs.Add(nodeID, nil, ids.GenerateTestID(), 1))
 		}
 
 		vdrs := validators.NewManager()
@@ -293,8 +291,7 @@ func newFullyConnectedTestNetwork(t *testing.T, handlers []router.InboundHandler
 		go func(net Network) {
 			defer wg.Done()
 
-			err := net.Dispatch()
-			require.NoError(err)
+			require.NoError(net.Dispatch())
 		}(net)
 	}
 
@@ -408,10 +405,9 @@ func TestTrackVerifiesSignatures(t *testing.T) {
 
 	network := networks[0].(*network)
 	nodeID, tlsCert, _ := getTLS(t, 1)
-	err := validators.Add(network.config.Validators, constants.PrimaryNetworkID, nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(validators.Add(network.config.Validators, constants.PrimaryNetworkID, nodeID, nil, ids.Empty, 1))
 
-	_, err = network.Track(ids.EmptyNodeID, []*ips.ClaimedIPPort{{
+	_, err := network.Track(ids.EmptyNodeID, []*ips.ClaimedIPPort{{
 		Cert: tlsCert.Leaf,
 		IPPort: ips.IPPort{
 			IP:   net.IPv4(123, 132, 123, 123),
@@ -453,14 +449,12 @@ func TestTrackDoesNotDialPrivateIPs(t *testing.T) {
 		}
 
 		beacons := validators.NewSet()
-		err = beacons.Add(nodeIDs[0], nil, ids.GenerateTestID(), 1)
-		require.NoError(err)
+		require.NoError(beacons.Add(nodeIDs[0], nil, ids.GenerateTestID(), 1))
 
 		primaryVdrs := validators.NewSet()
 		primaryVdrs.RegisterCallbackListener(&gossipTrackerCallback)
 		for _, nodeID := range nodeIDs {
-			err := primaryVdrs.Add(nodeID, nil, ids.GenerateTestID(), 1)
-			require.NoError(err)
+			require.NoError(primaryVdrs.Add(nodeID, nil, ids.GenerateTestID(), 1))
 		}
 
 		vdrs := validators.NewManager()
@@ -503,8 +497,7 @@ func TestTrackDoesNotDialPrivateIPs(t *testing.T) {
 		go func(net Network) {
 			defer wg.Done()
 
-			err := net.Dispatch()
-			require.NoError(err)
+			require.NoError(net.Dispatch())
 		}(net)
 	}
 
@@ -536,8 +529,7 @@ func TestDialDeletesNonValidators(t *testing.T) {
 
 	primaryVdrs := validators.NewSet()
 	for _, nodeID := range nodeIDs {
-		err := primaryVdrs.Add(nodeID, nil, ids.GenerateTestID(), 1)
-		require.NoError(err)
+		require.NoError(primaryVdrs.Add(nodeID, nil, ids.GenerateTestID(), 1))
 	}
 
 	networks := make([]Network, len(configs))
@@ -555,8 +547,7 @@ func TestDialDeletesNonValidators(t *testing.T) {
 		}
 
 		beacons := validators.NewSet()
-		err = beacons.Add(nodeIDs[0], nil, ids.GenerateTestID(), 1)
-		require.NoError(err)
+		require.NoError(beacons.Add(nodeIDs[0], nil, ids.GenerateTestID(), 1))
 
 		primaryVdrs.RegisterCallbackListener(&gossipTrackerCallback)
 
@@ -613,8 +604,7 @@ func TestDialDeletesNonValidators(t *testing.T) {
 		go func(net Network) {
 			defer wg.Done()
 
-			err := net.Dispatch()
-			require.NoError(err)
+			require.NoError(net.Dispatch())
 		}(net)
 	}
 
diff --git a/network/peer/peer_test.go b/network/peer/peer_test.go
index d956226d38d9..89ac57ef42d8 100644
--- a/network/peer/peer_test.go
+++ b/network/peer/peer_test.go
@@ -190,13 +190,11 @@ func makeReadyTestPeers(t *testing.T, trackedSubnets set.Set[ids.ID]) (*testPeer
 
 	peer0, peer1 := makeTestPeers(t, trackedSubnets)
 
-	err := peer0.AwaitReady(context.Background())
-	require.NoError(err)
+	require.NoError(peer0.AwaitReady(context.Background()))
 	isReady := peer0.Ready()
 	require.True(isReady)
 
-	err = peer1.AwaitReady(context.Background())
-	require.NoError(err)
+	require.NoError(peer1.AwaitReady(context.Background()))
 	isReady = peer1.Ready()
 	require.True(isReady)
 
@@ -236,21 +234,17 @@ func TestReady(t *testing.T) {
 		),
 	)
 
-	err := peer0.AwaitReady(context.Background())
-	require.NoError(err)
+	require.NoError(peer0.AwaitReady(context.Background()))
 	isReady = peer0.Ready()
 	require.True(isReady)
 
-	err = peer1.AwaitReady(context.Background())
-	require.NoError(err)
+	require.NoError(peer1.AwaitReady(context.Background()))
 	isReady = peer1.Ready()
 	require.True(isReady)
 
 	peer0.StartClose()
-	err = peer0.AwaitClosed(context.Background())
-	require.NoError(err)
-	err = peer1.AwaitClosed(context.Background())
-	require.NoError(err)
+	require.NoError(peer0.AwaitClosed(context.Background()))
+	require.NoError(peer1.AwaitClosed(context.Background()))
 }
 
 func TestSend(t *testing.T) {
@@ -269,10 +263,8 @@ func TestSend(t *testing.T) {
 	require.Equal(message.GetOp, inboundGetMsg.Op())
 
 	peer1.StartClose()
-	err = peer0.AwaitClosed(context.Background())
-	require.NoError(err)
-	err = peer1.AwaitClosed(context.Background())
-	require.NoError(err)
+	require.NoError(peer0.AwaitClosed(context.Background()))
+	require.NoError(peer1.AwaitClosed(context.Background()))
 }
 
 func TestPingUptimes(t *testing.T) {
diff --git a/network/throttling/dial_throttler_test.go b/network/throttling/dial_throttler_test.go
index fdc491cf8981..f8e33846e0a5 100644
--- a/network/throttling/dial_throttler_test.go
+++ b/network/throttling/dial_throttler_test.go
@@ -21,8 +21,7 @@ func TestDialThrottler(t *testing.T) {
 		acquiredChan := make(chan struct{}, 1)
 		// Should return immediately because < 5 taken this second
 		go func() {
-			err := throttler.Acquire(context.Background())
-			require.NoError(t, err)
+			require.NoError(t, throttler.Acquire(context.Background()))
 			acquiredChan <- struct{}{}
 		}()
 		select {
@@ -36,8 +35,7 @@ func TestDialThrottler(t *testing.T) {
 	acquiredChan := make(chan struct{}, 1)
 	go func() {
 		// Should block because 5 already taken within last second
-		err := throttler.Acquire(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, throttler.Acquire(context.Background()))
 		acquiredChan <- struct{}{}
 	}()
 
@@ -68,8 +66,7 @@ func TestDialThrottlerCancel(t *testing.T) {
 		acquiredChan := make(chan struct{}, 1)
 		// Should return immediately because < 5 taken this second
 		go func() {
-			err := throttler.Acquire(context.Background())
-			require.NoError(t, err)
+			require.NoError(t, throttler.Acquire(context.Background()))
 			acquiredChan <- struct{}{}
 		}()
 		select {
@@ -105,8 +102,7 @@ func TestNoDialThrottler(t *testing.T) {
 	throttler := NewNoDialThrottler()
 	for i := 0; i < 250; i++ {
 		startTime := time.Now()
-		err := throttler.Acquire(context.Background()) // Should always immediately return
-		require.NoError(t, err)
+		require.NoError(t, throttler.Acquire(context.Background())) // Should always immediately return
 		require.WithinDuration(t, time.Now(), startTime, 25*time.Millisecond)
 	}
 }
diff --git a/network/throttling/inbound_conn_throttler_test.go b/network/throttling/inbound_conn_throttler_test.go
index 14f68167c3d1..5c28a45da20c 100644
--- a/network/throttling/inbound_conn_throttler_test.go
+++ b/network/throttling/inbound_conn_throttler_test.go
@@ -56,8 +56,7 @@ func TestInboundConnThrottlerClose(t *testing.T) {
 		},
 	}
 	wrappedL := NewThrottledListener(l, 1)
-	err := wrappedL.Close()
-	require.NoError(err)
+	require.NoError(wrappedL.Close())
 	require.True(closed)
 
 	select {
@@ -67,7 +66,7 @@ func TestInboundConnThrottlerClose(t *testing.T) {
 	}
 
 	// Accept() should return an error because the context is cancelled
-	_, err = wrappedL.Accept()
+	_, err := wrappedL.Accept()
 	require.ErrorIs(err, context.Canceled)
 }
 
diff --git a/pubsub/filter_test.go b/pubsub/filter_test.go
index 051ad94c7a42..088d0ecee2d0 100644
--- a/pubsub/filter_test.go
+++ b/pubsub/filter_test.go
@@ -31,8 +31,7 @@ func TestAddAddressesParseAddresses(t *testing.T) {
 		},
 	}}
 
-	err = msg.parseAddresses()
-	require.NoError(err)
+	require.NoError(msg.parseAddresses())
 
 	require.Len(msg.addressIds, 1)
 	require.Equal(addrID[:], msg.addressIds[0])
diff --git a/scripts/lint.sh b/scripts/lint.sh
index 0ee52450050d..e15d12c0f334 100755
--- a/scripts/lint.sh
+++ b/scripts/lint.sh
@@ -21,7 +21,7 @@ fi
 # by default, "./scripts/lint.sh" runs all lint tests
 # to run only "license_header" test
 # TESTS='license_header' ./scripts/lint.sh
-TESTS=${TESTS:-"golangci_lint license_header require_error_is_no_funcs_as_params single_import interface_compliance_nil require_equal_zero require_len_zero require_equal_len require_nil"}
+TESTS=${TESTS:-"golangci_lint license_header require_error_is_no_funcs_as_params single_import interface_compliance_nil require_equal_zero require_len_zero require_equal_len require_nil require_no_error_inline_func"}
 
 function test_golangci_lint {
   go install -v github.com/golangci/golangci-lint/cmd/golangci-lint@v1.51.2
@@ -125,6 +125,15 @@ function test_require_nil {
   fi
 }
 
+function test_require_no_error_inline_func {
+  if grep -R -zo -P '\t+err :?= ((?!require|if).|\n)*require\.NoError\((t, )?err\)' .; then
+    echo ""
+    echo "Checking that a function with a single error return doesn't error should be done in-line."
+    echo ""
+    return 1
+  fi
+}
+
 # Ref: https://go.dev/doc/effective_go#blank_implements
 function test_interface_compliance_nil {
   if grep -R -o -P '_ .+? = &.+?\{\}' .; then
diff --git a/snow/consensus/snowman/consensus_test.go b/snow/consensus/snowman/consensus_test.go
index 99abfbf31739..0affcf871554 100644
--- a/snow/consensus/snowman/consensus_test.go
+++ b/snow/consensus/snowman/consensus_test.go
@@ -1080,8 +1080,7 @@ func RecordPollDivergedVotingTest(t *testing.T, factory Factory) {
 		MaxOutstandingItems:   1,
 		MaxItemProcessingTime: 1,
 	}
-	err := sm.Initialize(ctx, params, GenesisID, GenesisHeight, GenesisTimestamp)
-	require.NoError(err)
+	require.NoError(sm.Initialize(ctx, params, GenesisID, GenesisHeight, GenesisTimestamp))
 
 	block0 := &TestBlock{
 		TestDecidable: choices.TestDecidable{
@@ -1116,31 +1115,26 @@ func RecordPollDivergedVotingTest(t *testing.T, factory Factory) {
 		HeightV: block2.HeightV + 1,
 	}
 
-	err = sm.Add(context.Background(), block0)
-	require.NoError(err)
+	require.NoError(sm.Add(context.Background(), block0))
 
-	err = sm.Add(context.Background(), block1)
-	require.NoError(err)
+	require.NoError(sm.Add(context.Background(), block1))
 
 	// The first bit is contested as either 0 or 1. When voting for [block0] and
 	// when the first bit is 1, the following bits have been decided to follow
 	// the 255 remaining bits of [block0].
 	votes0 := bag.Bag[ids.ID]{}
 	votes0.Add(block0.ID())
-	err = sm.RecordPoll(context.Background(), votes0)
-	require.NoError(err)
+	require.NoError(sm.RecordPoll(context.Background(), votes0))
 
 	// Although we are adding in [block2] here - the underlying snowball
 	// instance has already decided it is rejected. Snowman doesn't actually
 	// know that though, because that is an implementation detail of the
 	// Snowball trie that is used.
-	err = sm.Add(context.Background(), block2)
-	require.NoError(err)
+	require.NoError(sm.Add(context.Background(), block2))
 
 	// Because [block2] is effectively rejected, [block3] is also effectively
 	// rejected.
-	err = sm.Add(context.Background(), block3)
-	require.NoError(err)
+	require.NoError(sm.Add(context.Background(), block3))
 
 	require.Equal(block0.ID(), sm.Preference())
 	require.Equal(choices.Processing, block0.Status(), "should not be accepted yet")
@@ -1166,8 +1160,7 @@ func RecordPollDivergedVotingTest(t *testing.T, factory Factory) {
 	// transitively.
 	votes3 := bag.Bag[ids.ID]{}
 	votes3.Add(block3.ID())
-	err = sm.RecordPoll(context.Background(), votes3)
-	require.NoError(err)
+	require.NoError(sm.RecordPoll(context.Background(), votes3))
 
 	require.True(sm.Finalized(), "finalized too late")
 	require.Equal(choices.Accepted, block0.Status(), "should be accepted")
diff --git a/snow/engine/common/queue/jobs_test.go b/snow/engine/common/queue/jobs_test.go
index 8a5205af6986..68bc8a1b7d8a 100644
--- a/snow/engine/common/queue/jobs_test.go
+++ b/snow/engine/common/queue/jobs_test.go
@@ -104,8 +104,7 @@ func TestPushAndExecute(t *testing.T) {
 	require.NoError(err)
 	require.True(has)
 
-	err = jobs.Commit()
-	require.NoError(err)
+	require.NoError(jobs.Commit())
 
 	jobs, err = New(db, "", prometheus.NewRegistry())
 	require.NoError(err)
@@ -233,8 +232,7 @@ func TestDuplicatedExecutablePush(t *testing.T) {
 	require.False(pushed)
 	require.NoError(err)
 
-	err = jobs.Commit()
-	require.NoError(err)
+	require.NoError(jobs.Commit())
 
 	jobs, err = New(db, "", prometheus.NewRegistry())
 	require.NoError(err)
@@ -267,8 +265,7 @@ func TestDuplicatedNotExecutablePush(t *testing.T) {
 	require.False(pushed)
 	require.NoError(err)
 
-	err = jobs.Commit()
-	require.NoError(err)
+	require.NoError(jobs.Commit())
 
 	jobs, err = New(db, "", prometheus.NewRegistry())
 	require.NoError(err)
@@ -296,8 +293,7 @@ func TestMissingJobs(t *testing.T) {
 	jobs.AddMissingID(job0ID)
 	jobs.AddMissingID(job1ID)
 
-	err = jobs.Commit()
-	require.NoError(err)
+	require.NoError(jobs.Commit())
 
 	numMissingIDs := jobs.NumMissingIDs()
 	require.Equal(2, numMissingIDs)
@@ -313,8 +309,7 @@ func TestMissingJobs(t *testing.T) {
 
 	jobs.RemoveMissingID(job1ID)
 
-	err = jobs.Commit()
-	require.NoError(err)
+	require.NoError(jobs.Commit())
 
 	jobs, err = NewWithMissing(db, "", prometheus.NewRegistry())
 	require.NoError(err)
@@ -489,14 +484,9 @@ func TestInitializeNumJobs(t *testing.T) {
 	require.NoError(err)
 	require.Equal(uint64(2), jobs.state.numJobs)
 
-	err = jobs.Commit()
-	require.NoError(err)
-
-	err = database.Clear(jobs.state.metadataDB, jobs.state.metadataDB)
-	require.NoError(err)
-
-	err = jobs.Commit()
-	require.NoError(err)
+	require.NoError(jobs.Commit())
+	require.NoError(database.Clear(jobs.state.metadataDB, jobs.state.metadataDB))
+	require.NoError(jobs.Commit())
 
 	jobs, err = NewWithMissing(db, "", prometheus.NewRegistry())
 	if err != nil {
diff --git a/snow/engine/common/tracker/peers_test.go b/snow/engine/common/tracker/peers_test.go
index 802386f84686..bae131cbae0e 100644
--- a/snow/engine/common/tracker/peers_test.go
+++ b/snow/engine/common/tracker/peers_test.go
@@ -27,8 +27,7 @@ func TestPeers(t *testing.T) {
 	require.Zero(p.ConnectedWeight())
 	require.Empty(p.PreferredPeers())
 
-	err := p.Connected(context.Background(), nodeID, version.CurrentApp)
-	require.NoError(err)
+	require.NoError(p.Connected(context.Background(), nodeID, version.CurrentApp))
 	require.Equal(uint64(5), p.ConnectedWeight())
 	require.Contains(p.PreferredPeers(), nodeID)
 
@@ -44,8 +43,7 @@ func TestPeers(t *testing.T) {
 	require.Equal(uint64(5), p.ConnectedWeight())
 	require.Contains(p.PreferredPeers(), nodeID)
 
-	err = p.Disconnected(context.Background(), nodeID)
-	require.NoError(err)
+	require.NoError(p.Disconnected(context.Background(), nodeID))
 	require.Zero(p.ConnectedWeight())
 	require.Empty(p.PreferredPeers())
 }
diff --git a/snow/engine/snowman/transitive_test.go b/snow/engine/snowman/transitive_test.go
index 6657f8ae83b6..bc55e42bdf84 100644
--- a/snow/engine/snowman/transitive_test.go
+++ b/snow/engine/snowman/transitive_test.go
@@ -1190,8 +1190,7 @@ func TestEngineAbandonChit(t *testing.T) {
 		reqID = requestID
 	}
 
-	err := te.issue(context.Background(), blk)
-	require.NoError(err)
+	require.NoError(te.issue(context.Background(), blk))
 
 	fakeBlkID := ids.GenerateTestID()
 	vm.GetBlockF = func(_ context.Context, id ids.ID) (snowman.Block, error) {
@@ -1204,14 +1203,12 @@ func TestEngineAbandonChit(t *testing.T) {
 	}
 
 	// Register a voter dependency on an unknown block.
-	err = te.Chits(context.Background(), vdr, reqID, []ids.ID{fakeBlkID}, nil)
-	require.NoError(err)
+	require.NoError(te.Chits(context.Background(), vdr, reqID, []ids.ID{fakeBlkID}, nil))
 	require.Len(te.blocked, 1)
 
 	sender.CantSendPullQuery = false
 
-	err = te.GetFailed(context.Background(), vdr, reqID)
-	require.NoError(err)
+	require.NoError(te.GetFailed(context.Background(), vdr, reqID))
 	require.Empty(te.blocked)
 }
 
@@ -1248,8 +1245,7 @@ func TestEngineAbandonChitWithUnexpectedPutBlock(t *testing.T) {
 		reqID = requestID
 	}
 
-	err := te.issue(context.Background(), blk)
-	require.NoError(err)
+	require.NoError(te.issue(context.Background(), blk))
 
 	fakeBlkID := ids.GenerateTestID()
 	vm.GetBlockF = func(_ context.Context, id ids.ID) (snowman.Block, error) {
@@ -1262,8 +1258,7 @@ func TestEngineAbandonChitWithUnexpectedPutBlock(t *testing.T) {
 	}
 
 	// Register a voter dependency on an unknown block.
-	err = te.Chits(context.Background(), vdr, reqID, []ids.ID{fakeBlkID}, nil)
-	require.NoError(err)
+	require.NoError(te.Chits(context.Background(), vdr, reqID, []ids.ID{fakeBlkID}, nil))
 	require.Len(te.blocked, 1)
 
 	sender.CantSendPullQuery = false
@@ -1276,8 +1271,7 @@ func TestEngineAbandonChitWithUnexpectedPutBlock(t *testing.T) {
 
 	// Respond with an unexpected block and verify that the request is correctly
 	// cleared.
-	err = te.Put(context.Background(), vdr, reqID, gBlkBytes)
-	require.NoError(err)
+	require.NoError(te.Put(context.Background(), vdr, reqID, gBlkBytes))
 	require.Empty(te.blocked)
 }
 
@@ -3240,8 +3234,7 @@ func TestEngineBuildBlockWithCachedNonVerifiedParent(t *testing.T) {
 	}
 
 	// Give the engine the grandparent
-	err := te.Put(context.Background(), vdr, 0, grandParentBlk.BytesV)
-	require.NoError(err)
+	require.NoError(te.Put(context.Background(), vdr, 0, grandParentBlk.BytesV))
 
 	vm.ParseBlockF = func(_ context.Context, b []byte) (snowman.Block, error) {
 		require.Equal(parentBlkA.BytesV, b)
@@ -3251,8 +3244,7 @@ func TestEngineBuildBlockWithCachedNonVerifiedParent(t *testing.T) {
 	// Give the node [parentBlkA]/[parentBlkB].
 	// When it's parsed we get [parentBlkA] (not [parentBlkB]).
 	// [parentBlkA] fails verification and gets put into [te.nonVerifiedCache].
-	err = te.Put(context.Background(), vdr, 0, parentBlkA.BytesV)
-	require.NoError(err)
+	require.NoError(te.Put(context.Background(), vdr, 0, parentBlkA.BytesV))
 
 	vm.ParseBlockF = func(_ context.Context, b []byte) (snowman.Block, error) {
 		require.Equal(parentBlkB.BytesV, b)
@@ -3284,15 +3276,11 @@ func TestEngineBuildBlockWithCachedNonVerifiedParent(t *testing.T) {
 	// When we fetch it using [GetBlockF] we get [parentBlkB].
 	// Note that [parentBlkB] doesn't fail verification and is issued into consensus.
 	// This evicts [parentBlkA] from [te.nonVerifiedCache].
-	err = te.Put(context.Background(), vdr, 0, parentBlkA.BytesV)
-	require.NoError(err)
+	require.NoError(te.Put(context.Background(), vdr, 0, parentBlkA.BytesV))
 
 	// Give 2 chits for [parentBlkA]/[parentBlkB]
-	err = te.Chits(context.Background(), vdr, *queryRequestAID, []ids.ID{parentBlkB.IDV}, nil)
-	require.NoError(err)
-
-	err = te.Chits(context.Background(), vdr, *queryRequestGPID, []ids.ID{parentBlkB.IDV}, nil)
-	require.NoError(err)
+	require.NoError(te.Chits(context.Background(), vdr, *queryRequestAID, []ids.ID{parentBlkB.IDV}, nil))
+	require.NoError(te.Chits(context.Background(), vdr, *queryRequestGPID, []ids.ID{parentBlkB.IDV}, nil))
 
 	// Assert that the blocks' statuses are correct.
 	// The evicted [parentBlkA] shouldn't be changed.
@@ -3309,8 +3297,7 @@ func TestEngineBuildBlockWithCachedNonVerifiedParent(t *testing.T) {
 	}
 
 	// Should issue a new block and send a query for it.
-	err = te.Notify(context.Background(), common.PendingTxs)
-	require.NoError(err)
+	require.NoError(te.Notify(context.Background(), common.PendingTxs))
 	require.True(*sentQuery)
 }
 
diff --git a/snow/networking/handler/handler_test.go b/snow/networking/handler/handler_test.go
index b9e757b7d99d..ccc694ae1991 100644
--- a/snow/networking/handler/handler_test.go
+++ b/snow/networking/handler/handler_test.go
@@ -39,8 +39,7 @@ func TestHandlerDropsTimedOutMessages(t *testing.T) {
 
 	vdrs := validators.NewSet()
 	vdr0 := ids.GenerateTestNodeID()
-	err := vdrs.Add(vdr0, nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(vdr0, nil, ids.Empty, 1))
 
 	resourceTracker, err := tracker.NewResourceTracker(
 		prometheus.NewRegistry(),
@@ -134,8 +133,7 @@ func TestHandlerClosesOnError(t *testing.T) {
 	ctx := snow.DefaultConsensusContextTest()
 
 	vdrs := validators.NewSet()
-	err := vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
 	resourceTracker, err := tracker.NewResourceTracker(
 		prometheus.NewRegistry(),
@@ -225,8 +223,7 @@ func TestHandlerDropsGossipDuringBootstrapping(t *testing.T) {
 	closed := make(chan struct{}, 1)
 	ctx := snow.DefaultConsensusContextTest()
 	vdrs := validators.NewSet()
-	err := vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
 	resourceTracker, err := tracker.NewResourceTracker(
 		prometheus.NewRegistry(),
@@ -305,8 +302,7 @@ func TestHandlerDispatchInternal(t *testing.T) {
 	ctx := snow.DefaultConsensusContextTest()
 	msgFromVMChan := make(chan common.Message)
 	vdrs := validators.NewSet()
-	err := vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
 	resourceTracker, err := tracker.NewResourceTracker(
 		prometheus.NewRegistry(),
@@ -376,8 +372,7 @@ func TestHandlerDispatchInternal(t *testing.T) {
 func TestHandlerSubnetConnector(t *testing.T) {
 	ctx := snow.DefaultConsensusContextTest()
 	vdrs := validators.NewSet()
-	err := vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
 	resourceTracker, err := tracker.NewResourceTracker(
 		prometheus.NewRegistry(),
@@ -553,8 +548,7 @@ func TestDynamicEngineTypeDispatch(t *testing.T) {
 			messageReceived := make(chan struct{})
 			ctx := snow.DefaultConsensusContextTest()
 			vdrs := validators.NewSet()
-			err := vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-			require.NoError(t, err)
+			require.NoError(t, vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
 			resourceTracker, err := tracker.NewResourceTracker(
 				prometheus.NewRegistry(),
diff --git a/snow/networking/router/chain_router_test.go b/snow/networking/router/chain_router_test.go
index 1ba900e283b2..2027f2ddb2b7 100644
--- a/snow/networking/router/chain_router_test.go
+++ b/snow/networking/router/chain_router_test.go
@@ -45,9 +45,7 @@ func TestShutdown(t *testing.T) {
 	require := require.New(t)
 
 	vdrs := validators.NewSet()
-	err := vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(err)
-
+	require.NoError(vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 	benchlist := benchlist.NewNoBenchlist()
 	tm, err := timeout.NewManager(
 		&timer.AdaptiveTimeoutConfig{
@@ -65,7 +63,7 @@ func TestShutdown(t *testing.T) {
 	go tm.Dispatch()
 
 	chainRouter := ChainRouter{}
-	err = chainRouter.Initialize(
+	require.NoError(chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -77,8 +75,7 @@ func TestShutdown(t *testing.T) {
 		HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(err)
+	))
 
 	shutdownCalled := make(chan struct{}, 1)
 
@@ -183,8 +180,7 @@ func TestShutdown(t *testing.T) {
 func TestShutdownTimesOut(t *testing.T) {
 	nodeID := ids.EmptyNodeID
 	vdrs := validators.NewSet()
-	err := vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 	benchlist := benchlist.NewNoBenchlist()
 	metrics := prometheus.NewRegistry()
 	// Ensure that the Ancestors request does not timeout
@@ -205,7 +201,7 @@ func TestShutdownTimesOut(t *testing.T) {
 
 	chainRouter := ChainRouter{}
 
-	err = chainRouter.Initialize(
+	require.NoError(t, chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -217,8 +213,7 @@ func TestShutdownTimesOut(t *testing.T) {
 		HealthConfig{},
 		"",
 		metrics,
-	)
-	require.NoError(t, err)
+	))
 
 	ctx := snow.DefaultConsensusContextTest()
 	resourceTracker, err := tracker.NewResourceTracker(
@@ -344,8 +339,7 @@ func TestRouterTimeout(t *testing.T) {
 
 	// Create a router
 	chainRouter := ChainRouter{}
-
-	err = chainRouter.Initialize(
+	require.NoError(chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -357,8 +351,7 @@ func TestRouterTimeout(t *testing.T) {
 		HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(err)
+	))
 
 	// Create bootstrapper, engine and handler
 	var (
@@ -374,8 +367,7 @@ func TestRouterTimeout(t *testing.T) {
 
 	ctx := snow.DefaultConsensusContextTest()
 	vdrs := validators.NewSet()
-	err = vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
 	resourceTracker, err := tracker.NewResourceTracker(
 		prometheus.NewRegistry(),
@@ -702,7 +694,7 @@ func TestRouterHonorsRequestedEngine(t *testing.T) {
 
 	// Create a router
 	chainRouter := ChainRouter{}
-	err = chainRouter.Initialize(
+	require.NoError(chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -714,8 +706,7 @@ func TestRouterHonorsRequestedEngine(t *testing.T) {
 		HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(err)
+	))
 
 	h := handler.NewMockHandler(ctrl)
 
@@ -828,7 +819,7 @@ func TestRouterClearTimeouts(t *testing.T) {
 
 	// Create a router
 	chainRouter := ChainRouter{}
-	err = chainRouter.Initialize(
+	require.NoError(t, chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -840,14 +831,12 @@ func TestRouterClearTimeouts(t *testing.T) {
 		HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(t, err)
+	))
 
 	// Create bootstrapper, engine and handler
 	ctx := snow.DefaultConsensusContextTest()
 	vdrs := validators.NewSet()
-	err = vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
 	resourceTracker, err := tracker.NewResourceTracker(
 		prometheus.NewRegistry(),
@@ -1115,7 +1104,7 @@ func TestValidatorOnlyMessageDrops(t *testing.T) {
 
 	// Create a router
 	chainRouter := ChainRouter{}
-	err = chainRouter.Initialize(
+	require.NoError(t, chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -1127,8 +1116,7 @@ func TestValidatorOnlyMessageDrops(t *testing.T) {
 		HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(t, err)
+	))
 
 	// Create bootstrapper, engine and handler
 	calledF := false
@@ -1138,8 +1126,7 @@ func TestValidatorOnlyMessageDrops(t *testing.T) {
 	sb := subnets.New(ctx.NodeID, subnets.Config{ValidatorOnly: true})
 	vdrs := validators.NewSet()
 	vID := ids.GenerateTestNodeID()
-	err = vdrs.Add(vID, nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(vID, nil, ids.Empty, 1))
 	resourceTracker, err := tracker.NewResourceTracker(
 		prometheus.NewRegistry(),
 		resource.NoUsage,
@@ -1263,7 +1250,7 @@ func TestRouterCrossChainMessages(t *testing.T) {
 	// Create chain router
 	nodeID := ids.GenerateTestNodeID()
 	chainRouter := ChainRouter{}
-	err = chainRouter.Initialize(
+	require.NoError(t, chainRouter.Initialize(
 		nodeID,
 		logging.NoLog{},
 		tm,
@@ -1275,8 +1262,7 @@ func TestRouterCrossChainMessages(t *testing.T) {
 		HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(t, err)
+	))
 
 	// Set up validators
 	vdrs := validators.NewSet()
@@ -1414,7 +1400,7 @@ func TestConnectedSubnet(t *testing.T) {
 	trackedSubnets := set.Set[ids.ID]{}
 	trackedSubnets.Add(subnetID0, subnetID1)
 	chainRouter := ChainRouter{}
-	err = chainRouter.Initialize(
+	require.NoError(t, chainRouter.Initialize(
 		myNodeID,
 		logging.NoLog{},
 		tm,
@@ -1426,8 +1412,7 @@ func TestConnectedSubnet(t *testing.T) {
 		HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(t, err)
+	))
 
 	// Create bootstrapper, engine and handler
 	platform := snow.DefaultConsensusContextTest()
@@ -1526,7 +1511,7 @@ func TestValidatorOnlyAllowedNodeMessageDrops(t *testing.T) {
 
 	// Create a router
 	chainRouter := ChainRouter{}
-	err = chainRouter.Initialize(
+	require.NoError(t, chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -1538,8 +1523,7 @@ func TestValidatorOnlyAllowedNodeMessageDrops(t *testing.T) {
 		HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(t, err)
+	))
 
 	// Create bootstrapper, engine and handler
 	calledF := false
@@ -1553,8 +1537,7 @@ func TestValidatorOnlyAllowedNodeMessageDrops(t *testing.T) {
 
 	vdrs := validators.NewSet()
 	vID := ids.GenerateTestNodeID()
-	err = vdrs.Add(vID, nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(vID, nil, ids.Empty, 1))
 
 	resourceTracker, err := tracker.NewResourceTracker(
 		prometheus.NewRegistry(),
diff --git a/snow/networking/sender/sender_test.go b/snow/networking/sender/sender_test.go
index 2950bbc86976..176ddba3ad4b 100644
--- a/snow/networking/sender/sender_test.go
+++ b/snow/networking/sender/sender_test.go
@@ -51,8 +51,7 @@ var defaultSubnetConfig = subnets.Config{
 func TestTimeout(t *testing.T) {
 	require := require.New(t)
 	vdrs := validators.NewSet()
-	err := vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 	benchlist := benchlist.NewNoBenchlist()
 	tm, err := timeout.NewManager(
 		&timer.AdaptiveTimeoutConfig{
@@ -81,7 +80,7 @@ func TestTimeout(t *testing.T) {
 	)
 	require.NoError(err)
 
-	err = chainRouter.Initialize(
+	require.NoError(chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -93,8 +92,7 @@ func TestTimeout(t *testing.T) {
 		router.HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(err)
+	))
 
 	ctx := snow.DefaultConsensusContextTest()
 	externalSender := &ExternalSenderTest{TB: t}
@@ -290,16 +288,14 @@ func TestTimeout(t *testing.T) {
 			vdrIDs.Union(nodeIDs)
 			wg.Add(1)
 			requestID++
-			err := sender.SendAppRequest(cancelledCtx, nodeIDs, requestID, nil)
-			require.NoError(err)
+			require.NoError(sender.SendAppRequest(cancelledCtx, nodeIDs, requestID, nil))
 		}
 		{
 			chainID := ids.GenerateTestID()
 			chains.Add(chainID)
 			wg.Add(1)
 			requestID++
-			err := sender.SendCrossChainAppRequest(cancelledCtx, chainID, requestID, nil)
-			require.NoError(err)
+			require.NoError(sender.SendCrossChainAppRequest(cancelledCtx, chainID, requestID, nil))
 		}
 	}
 
@@ -323,8 +319,7 @@ func TestTimeout(t *testing.T) {
 
 func TestReliableMessages(t *testing.T) {
 	vdrs := validators.NewSet()
-	err := vdrs.Add(ids.NodeID{1}, nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(ids.NodeID{1}, nil, ids.Empty, 1))
 	benchlist := benchlist.NewNoBenchlist()
 	tm, err := timeout.NewManager(
 		&timer.AdaptiveTimeoutConfig{
@@ -354,7 +349,7 @@ func TestReliableMessages(t *testing.T) {
 	)
 	require.NoError(t, err)
 
-	err = chainRouter.Initialize(
+	require.NoError(t, chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -366,8 +361,7 @@ func TestReliableMessages(t *testing.T) {
 		router.HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(t, err)
+	))
 
 	ctx := snow.DefaultConsensusContextTest()
 
@@ -473,8 +467,7 @@ func TestReliableMessages(t *testing.T) {
 func TestReliableMessagesToMyself(t *testing.T) {
 	benchlist := benchlist.NewNoBenchlist()
 	vdrs := validators.NewSet()
-	err := vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(t, err)
+	require.NoError(t, vdrs.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 	tm, err := timeout.NewManager(
 		&timer.AdaptiveTimeoutConfig{
 			InitialTimeout:     10 * time.Millisecond,
@@ -503,7 +496,7 @@ func TestReliableMessagesToMyself(t *testing.T) {
 	)
 	require.NoError(t, err)
 
-	err = chainRouter.Initialize(
+	require.NoError(t, chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		tm,
@@ -515,8 +508,7 @@ func TestReliableMessagesToMyself(t *testing.T) {
 		router.HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(t, err)
+	))
 
 	ctx := snow.DefaultConsensusContextTest()
 
diff --git a/snow/uptime/manager_test.go b/snow/uptime/manager_test.go
index 1f5a854e819a..f33953db4bc3 100644
--- a/snow/uptime/manager_test.go
+++ b/snow/uptime/manager_test.go
@@ -31,8 +31,7 @@ func TestStartTracking(t *testing.T) {
 	currentTime := startTime.Add(time.Second)
 	up.clock.Set(currentTime)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	duration, lastUpdated, err := up.CalculateUptime(nodeID0, subnetID)
 	require.NoError(err)
@@ -88,8 +87,7 @@ func TestStartTrackingInThePast(t *testing.T) {
 	currentTime := startTime.Add(-time.Second)
 	up.clock.Set(currentTime)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	duration, lastUpdated, err := up.CalculateUptime(nodeID0, subnetID)
 	require.NoError(err)
@@ -111,20 +109,17 @@ func TestStopTrackingDecreasesUptime(t *testing.T) {
 	up := NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	currentTime = startTime.Add(time.Second)
 	up.clock.Set(currentTime)
 
-	err = up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StopTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	up = NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err = up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	duration, lastUpdated, err := up.CalculateUptime(nodeID0, subnetID)
 	require.NoError(err)
@@ -146,23 +141,19 @@ func TestStopTrackingIncreasesUptime(t *testing.T) {
 	up := NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
-	err = up.Connect(nodeID0, subnetID)
-	require.NoError(err)
+	require.NoError(up.Connect(nodeID0, subnetID))
 
 	currentTime = startTime.Add(time.Second)
 	up.clock.Set(currentTime)
 
-	err = up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StopTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	up = NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err = up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	duration, lastUpdated, err := up.CalculateUptime(nodeID0, subnetID)
 	require.NoError(err)
@@ -179,10 +170,9 @@ func TestStopTrackingDisconnectedNonValidator(t *testing.T) {
 	s := NewTestState()
 	up := NewManager(s).(*manager)
 
-	err := up.StartTracking(nil, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking(nil, subnetID))
 
-	err = up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
+	err := up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
 	require.ErrorIs(err, database.ErrNotFound)
 }
 
@@ -197,14 +187,12 @@ func TestStopTrackingConnectedDBError(t *testing.T) {
 	s.AddNode(nodeID0, subnetID, startTime)
 	up := NewManager(s).(*manager)
 
-	err := up.StartTracking(nil, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking(nil, subnetID))
 
-	err = up.Connect(nodeID0, subnetID)
-	require.NoError(err)
+	require.NoError(up.Connect(nodeID0, subnetID))
 
 	s.dbReadError = errTest
-	err = up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
+	err := up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
 	require.ErrorIs(err, errTest)
 }
 
@@ -221,14 +209,12 @@ func TestStopTrackingNonConnectedPast(t *testing.T) {
 	up := NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	currentTime = currentTime.Add(-time.Second)
 	up.clock.Set(currentTime)
 
-	err = up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StopTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	duration, lastUpdated, err := s.GetUptime(nodeID0, subnetID)
 	require.NoError(err)
@@ -249,14 +235,13 @@ func TestStopTrackingNonConnectedDBError(t *testing.T) {
 	up := NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	currentTime = currentTime.Add(time.Second)
 	up.clock.Set(currentTime)
 
 	s.dbWriteError = errTest
-	err = up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
+	err := up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
 	require.ErrorIs(err, errTest)
 }
 
@@ -292,8 +277,7 @@ func TestConnectAndDisconnect(t *testing.T) {
 				connected := up.IsConnected(nodeID0, subnetID)
 				require.False(connected)
 
-				err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-				require.NoError(err)
+				require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 				connected = up.IsConnected(nodeID0, subnetID)
 				require.False(connected)
@@ -303,8 +287,7 @@ func TestConnectAndDisconnect(t *testing.T) {
 				require.Equal(time.Duration(0), duration)
 				require.Equal(up.clock.UnixTime(), lastUpdated)
 
-				err = up.Connect(nodeID0, subnetID)
-				require.NoError(err)
+				require.NoError(up.Connect(nodeID0, subnetID))
 
 				connected = up.IsConnected(nodeID0, subnetID)
 				require.True(connected)
@@ -320,8 +303,7 @@ func TestConnectAndDisconnect(t *testing.T) {
 				require.Equal(up.clock.UnixTime(), lastUpdated)
 			}
 
-			err := up.Disconnect(nodeID0)
-			require.NoError(err)
+			require.NoError(up.Disconnect(nodeID0))
 
 			for _, subnetID := range tt.subnetIDs {
 				connected := up.IsConnected(nodeID0, subnetID)
@@ -356,17 +338,14 @@ func TestConnectAndDisconnectBeforeTracking(t *testing.T) {
 	currentTime = currentTime.Add(time.Second)
 	up.clock.Set(currentTime)
 
-	err := up.Connect(nodeID0, subnetID)
-	require.NoError(err)
+	require.NoError(up.Connect(nodeID0, subnetID))
 
 	currentTime = currentTime.Add(time.Second)
 	up.clock.Set(currentTime)
 
-	err = up.Disconnect(nodeID0)
-	require.NoError(err)
+	require.NoError(up.Disconnect(nodeID0))
 
-	err = up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	duration, lastUpdated, err := up.CalculateUptime(nodeID0, subnetID)
 	require.NoError(err)
@@ -389,19 +368,16 @@ func TestUnrelatedNodeDisconnect(t *testing.T) {
 	up := NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	duration, lastUpdated, err := up.CalculateUptime(nodeID0, subnetID)
 	require.NoError(err)
 	require.Equal(time.Duration(0), duration)
 	require.Equal(up.clock.UnixTime(), lastUpdated)
 
-	err = up.Connect(nodeID0, subnetID)
-	require.NoError(err)
+	require.NoError(up.Connect(nodeID0, subnetID))
 
-	err = up.Connect(nodeID1, subnetID)
-	require.NoError(err)
+	require.NoError(up.Connect(nodeID1, subnetID))
 
 	currentTime = currentTime.Add(time.Second)
 	up.clock.Set(currentTime)
@@ -411,8 +387,7 @@ func TestUnrelatedNodeDisconnect(t *testing.T) {
 	require.Equal(time.Second, duration)
 	require.Equal(up.clock.UnixTime(), lastUpdated)
 
-	err = up.Disconnect(nodeID1)
-	require.NoError(err)
+	require.NoError(up.Disconnect(nodeID1))
 
 	currentTime = currentTime.Add(time.Second)
 	up.clock.Set(currentTime)
@@ -459,8 +434,7 @@ func TestCalculateUptimeWhenNeverConnected(t *testing.T) {
 
 	up := NewManager(s).(*manager)
 
-	err := up.StartTracking([]ids.NodeID{}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{}, subnetID))
 
 	s.AddNode(nodeID0, subnetID, startTime)
 
@@ -491,14 +465,12 @@ func TestCalculateUptimeWhenConnectedBeforeTracking(t *testing.T) {
 	up := NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err := up.Connect(nodeID0, subnetID)
-	require.NoError(err)
+	require.NoError(up.Connect(nodeID0, subnetID))
 
 	currentTime = currentTime.Add(time.Second)
 	up.clock.Set(currentTime)
 
-	err = up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	currentTime = currentTime.Add(time.Second)
 	up.clock.Set(currentTime)
@@ -523,14 +495,12 @@ func TestCalculateUptimeWhenConnectedInFuture(t *testing.T) {
 	up := NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	currentTime = currentTime.Add(2 * time.Second)
 	up.clock.Set(currentTime)
 
-	err = up.Connect(nodeID0, subnetID)
-	require.NoError(err)
+	require.NoError(up.Connect(nodeID0, subnetID))
 
 	currentTime = currentTime.Add(-time.Second)
 	up.clock.Set(currentTime)
@@ -588,8 +558,7 @@ func TestCalculateUptimePercentage(t *testing.T) {
 
 	up := NewManager(s).(*manager)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	currentTime = currentTime.Add(time.Second)
 	up.clock.Set(currentTime)
@@ -613,17 +582,14 @@ func TestStopTrackingUnixTimeRegression(t *testing.T) {
 	up := NewManager(s).(*manager)
 	up.clock.Set(currentTime)
 
-	err := up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
-	err = up.Connect(nodeID0, subnetID)
-	require.NoError(err)
+	require.NoError(up.Connect(nodeID0, subnetID))
 
 	currentTime = startTime.Add(time.Second)
 	up.clock.Set(currentTime)
 
-	err = up.StopTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StopTracking([]ids.NodeID{nodeID0}, subnetID))
 
 	currentTime = startTime.Add(time.Second)
 	up.clock.Set(currentTime)
@@ -633,11 +599,9 @@ func TestStopTrackingUnixTimeRegression(t *testing.T) {
 	currentTime = startTime.Add(time.Second)
 	up.clock.Set(currentTime)
 
-	err = up.StartTracking([]ids.NodeID{nodeID0}, subnetID)
-	require.NoError(err)
+	require.NoError(up.StartTracking([]ids.NodeID{nodeID0}, subnetID))
 
-	err = up.Connect(nodeID0, subnetID)
-	require.NoError(err)
+	require.NoError(up.Connect(nodeID0, subnetID))
 
 	currentTime = startTime.Add(time.Second)
 	up.clock.Set(currentTime)
diff --git a/snow/validators/manager_test.go b/snow/validators/manager_test.go
index 1b500d58d06a..d5f26c8d5871 100644
--- a/snow/validators/manager_test.go
+++ b/snow/validators/manager_test.go
@@ -25,8 +25,7 @@ func TestAdd(t *testing.T) {
 	s := NewSet()
 	m.Add(subnetID, s)
 
-	err = Add(m, subnetID, nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(Add(m, subnetID, nodeID, nil, ids.Empty, 1))
 
 	require.Equal(uint64(1), s.Weight())
 }
@@ -48,11 +47,9 @@ func TestAddWeight(t *testing.T) {
 	err = AddWeight(m, subnetID, nodeID, 1)
 	require.ErrorIs(err, errMissingValidator)
 
-	err = Add(m, subnetID, nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(Add(m, subnetID, nodeID, nil, ids.Empty, 1))
 
-	err = AddWeight(m, subnetID, nodeID, 1)
-	require.NoError(err)
+	require.NoError(AddWeight(m, subnetID, nodeID, 1))
 
 	require.Equal(uint64(2), s.Weight())
 }
@@ -71,16 +68,13 @@ func TestRemoveWeight(t *testing.T) {
 	s := NewSet()
 	m.Add(subnetID, s)
 
-	err = Add(m, subnetID, nodeID, nil, ids.Empty, 2)
-	require.NoError(err)
+	require.NoError(Add(m, subnetID, nodeID, nil, ids.Empty, 2))
 
-	err = RemoveWeight(m, subnetID, nodeID, 1)
-	require.NoError(err)
+	require.NoError(RemoveWeight(m, subnetID, nodeID, 1))
 
 	require.Equal(uint64(1), s.Weight())
 
-	err = RemoveWeight(m, subnetID, nodeID, 1)
-	require.NoError(err)
+	require.NoError(RemoveWeight(m, subnetID, nodeID, 1))
 
 	require.Zero(s.Weight())
 }
@@ -102,14 +96,12 @@ func TestContains(t *testing.T) {
 	contains = Contains(m, subnetID, nodeID)
 	require.False(contains)
 
-	err := Add(m, subnetID, nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(Add(m, subnetID, nodeID, nil, ids.Empty, 1))
 
 	contains = Contains(m, subnetID, nodeID)
 	require.True(contains)
 
-	err = RemoveWeight(m, subnetID, nodeID, 1)
-	require.NoError(err)
+	require.NoError(RemoveWeight(m, subnetID, nodeID, 1))
 
 	contains = Contains(m, subnetID, nodeID)
 	require.False(contains)
diff --git a/snow/validators/set_test.go b/snow/validators/set_test.go
index cebd565ea65c..fe90c051c444 100644
--- a/snow/validators/set_test.go
+++ b/snow/validators/set_test.go
@@ -31,10 +31,9 @@ func TestSetAddDuplicate(t *testing.T) {
 	s := NewSet()
 
 	nodeID := ids.GenerateTestNodeID()
-	err := s.Add(nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID, nil, ids.Empty, 1))
 
-	err = s.Add(nodeID, nil, ids.Empty, 1)
+	err := s.Add(nodeID, nil, ids.Empty, 1)
 	require.ErrorIs(err, errDuplicateValidator)
 }
 
@@ -42,10 +41,9 @@ func TestSetAddOverflow(t *testing.T) {
 	require := require.New(t)
 
 	s := NewSet()
-	err := s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
-	err = s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, stdmath.MaxUint64)
+	err := s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, stdmath.MaxUint64)
 	require.ErrorIs(err, math.ErrOverflow)
 
 	require.Equal(uint64(1), s.Weight())
@@ -57,10 +55,9 @@ func TestSetAddWeightZeroWeight(t *testing.T) {
 	s := NewSet()
 
 	nodeID := ids.GenerateTestNodeID()
-	err := s.Add(nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID, nil, ids.Empty, 1))
 
-	err = s.AddWeight(nodeID, 0)
+	err := s.AddWeight(nodeID, 0)
 	require.ErrorIs(err, errZeroWeight)
 }
 
@@ -69,14 +66,12 @@ func TestSetAddWeightOverflow(t *testing.T) {
 
 	s := NewSet()
 
-	err := s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
 	nodeID := ids.GenerateTestNodeID()
-	err = s.Add(nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID, nil, ids.Empty, 1))
 
-	err = s.AddWeight(nodeID, stdmath.MaxUint64-1)
+	err := s.AddWeight(nodeID, stdmath.MaxUint64-1)
 	require.ErrorIs(err, math.ErrOverflow)
 
 	require.Equal(uint64(2), s.Weight())
@@ -91,8 +86,7 @@ func TestSetGetWeight(t *testing.T) {
 	weight := s.GetWeight(nodeID)
 	require.Zero(weight)
 
-	err := s.Add(nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID, nil, ids.Empty, 1))
 
 	require.Equal(uint64(1), s.GetWeight(nodeID))
 }
@@ -114,14 +108,11 @@ func TestSetSubsetWeight(t *testing.T) {
 
 	s := NewSet()
 
-	err := s.Add(nodeID0, nil, ids.Empty, weight0)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID0, nil, ids.Empty, weight0))
 
-	err = s.Add(nodeID1, nil, ids.Empty, weight1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID1, nil, ids.Empty, weight1))
 
-	err = s.Add(nodeID2, nil, ids.Empty, weight2)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID2, nil, ids.Empty, weight2))
 
 	expectedWeight := weight0 + weight1
 	subsetWeight := s.SubsetWeight(subset)
@@ -134,10 +125,9 @@ func TestSetRemoveWeightZeroWeight(t *testing.T) {
 	s := NewSet()
 
 	nodeID := ids.GenerateTestNodeID()
-	err := s.Add(nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID, nil, ids.Empty, 1))
 
-	err = s.RemoveWeight(nodeID, 0)
+	err := s.RemoveWeight(nodeID, 0)
 	require.ErrorIs(err, errZeroWeight)
 }
 
@@ -146,10 +136,9 @@ func TestSetRemoveWeightMissingValidator(t *testing.T) {
 
 	s := NewSet()
 
-	err := s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
-	err = s.RemoveWeight(ids.GenerateTestNodeID(), 1)
+	err := s.RemoveWeight(ids.GenerateTestNodeID(), 1)
 	require.ErrorIs(err, errMissingValidator)
 }
 
@@ -158,14 +147,12 @@ func TestSetRemoveWeightUnderflow(t *testing.T) {
 
 	s := NewSet()
 
-	err := s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(ids.GenerateTestNodeID(), nil, ids.Empty, 1))
 
 	nodeID := ids.GenerateTestNodeID()
-	err = s.Add(nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID, nil, ids.Empty, 1))
 
-	err = s.RemoveWeight(nodeID, 2)
+	err := s.RemoveWeight(nodeID, 2)
 	require.ErrorIs(err, math.ErrUnderflow)
 
 	require.Equal(uint64(2), s.Weight())
@@ -184,8 +171,7 @@ func TestSetGet(t *testing.T) {
 	require.NoError(err)
 
 	pk := bls.PublicFromSecretKey(sk)
-	err = s.Add(nodeID, pk, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID, pk, ids.Empty, 1))
 
 	vdr0, ok := s.Get(nodeID)
 	require.True(ok)
@@ -193,8 +179,7 @@ func TestSetGet(t *testing.T) {
 	require.Equal(pk, vdr0.PublicKey)
 	require.Equal(uint64(1), vdr0.Weight)
 
-	err = s.AddWeight(nodeID, 1)
-	require.NoError(err)
+	require.NoError(s.AddWeight(nodeID, 1))
 
 	vdr1, ok := s.Get(nodeID)
 	require.True(ok)
@@ -215,14 +200,12 @@ func TestSetContains(t *testing.T) {
 	contains := s.Contains(nodeID)
 	require.False(contains)
 
-	err := s.Add(nodeID, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID, nil, ids.Empty, 1))
 
 	contains = s.Contains(nodeID)
 	require.True(contains)
 
-	err = s.RemoveWeight(nodeID, 1)
-	require.NoError(err)
+	require.NoError(s.RemoveWeight(nodeID, 1))
 
 	contains = s.Contains(nodeID)
 	require.False(contains)
@@ -237,27 +220,23 @@ func TestSetLen(t *testing.T) {
 	require.Zero(len)
 
 	nodeID0 := ids.GenerateTestNodeID()
-	err := s.Add(nodeID0, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID0, nil, ids.Empty, 1))
 
 	len = s.Len()
 	require.Equal(1, len)
 
 	nodeID1 := ids.GenerateTestNodeID()
-	err = s.Add(nodeID1, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID1, nil, ids.Empty, 1))
 
 	len = s.Len()
 	require.Equal(2, len)
 
-	err = s.RemoveWeight(nodeID1, 1)
-	require.NoError(err)
+	require.NoError(s.RemoveWeight(nodeID1, 1))
 
 	len = s.Len()
 	require.Equal(1, len)
 
-	err = s.RemoveWeight(nodeID0, 1)
-	require.NoError(err)
+	require.NoError(s.RemoveWeight(nodeID0, 1))
 
 	len = s.Len()
 	require.Zero(len)
@@ -276,8 +255,7 @@ func TestSetList(t *testing.T) {
 
 	pk := bls.PublicFromSecretKey(sk)
 	nodeID0 := ids.GenerateTestNodeID()
-	err = s.Add(nodeID0, pk, ids.Empty, 2)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID0, pk, ids.Empty, 2))
 
 	list = s.List()
 	require.Len(list, 1)
@@ -288,8 +266,7 @@ func TestSetList(t *testing.T) {
 	require.Equal(uint64(2), node0.Weight)
 
 	nodeID1 := ids.GenerateTestNodeID()
-	err = s.Add(nodeID1, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID1, nil, ids.Empty, 1))
 
 	list = s.List()
 	require.Len(list, 2)
@@ -304,8 +281,7 @@ func TestSetList(t *testing.T) {
 	require.Nil(node1.PublicKey)
 	require.Equal(uint64(1), node1.Weight)
 
-	err = s.RemoveWeight(nodeID0, 1)
-	require.NoError(err)
+	require.NoError(s.RemoveWeight(nodeID0, 1))
 	require.Equal(nodeID0, node0.NodeID)
 	require.Equal(pk, node0.PublicKey)
 	require.Equal(uint64(2), node0.Weight)
@@ -323,8 +299,7 @@ func TestSetList(t *testing.T) {
 	require.Nil(node1.PublicKey)
 	require.Equal(uint64(1), node1.Weight)
 
-	err = s.RemoveWeight(nodeID0, 1)
-	require.NoError(err)
+	require.NoError(s.RemoveWeight(nodeID0, 1))
 
 	list = s.List()
 	require.Len(list, 1)
@@ -334,8 +309,7 @@ func TestSetList(t *testing.T) {
 	require.Nil(node0.PublicKey)
 	require.Equal(uint64(1), node0.Weight)
 
-	err = s.RemoveWeight(nodeID1, 1)
-	require.NoError(err)
+	require.NoError(s.RemoveWeight(nodeID1, 1))
 
 	list = s.List()
 	require.Empty(list)
@@ -350,11 +324,9 @@ func TestSetWeight(t *testing.T) {
 	weight1 := uint64(123)
 
 	s := NewSet()
-	err := s.Add(vdr0, nil, ids.Empty, weight0)
-	require.NoError(err)
+	require.NoError(s.Add(vdr0, nil, ids.Empty, weight0))
 
-	err = s.Add(vdr1, nil, ids.Empty, weight1)
-	require.NoError(err)
+	require.NoError(s.Add(vdr1, nil, ids.Empty, weight1))
 
 	setWeight := s.Weight()
 	expectedWeight := weight0 + weight1
@@ -375,8 +347,7 @@ func TestSetSample(t *testing.T) {
 
 	nodeID0 := ids.GenerateTestNodeID()
 	pk := bls.PublicFromSecretKey(sk)
-	err = s.Add(nodeID0, pk, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID0, pk, ids.Empty, 1))
 
 	sampled, err = s.Sample(1)
 	require.NoError(err)
@@ -386,8 +357,7 @@ func TestSetSample(t *testing.T) {
 	require.ErrorIs(err, sampler.ErrOutOfRange)
 
 	nodeID1 := ids.GenerateTestNodeID()
-	err = s.Add(nodeID1, nil, ids.Empty, stdmath.MaxInt64-1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID1, nil, ids.Empty, stdmath.MaxInt64-1))
 
 	sampled, err = s.Sample(1)
 	require.NoError(err)
@@ -412,11 +382,9 @@ func TestSetString(t *testing.T) {
 	}
 
 	s := NewSet()
-	err := s.Add(nodeID0, nil, ids.Empty, 1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID0, nil, ids.Empty, 1))
 
-	err = s.Add(nodeID1, nil, ids.Empty, stdmath.MaxInt64-1)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID1, nil, ids.Empty, stdmath.MaxInt64-1))
 
 	expected := "Validator Set: (Size = 2, Weight = 9223372036854775807)\n" +
 		"    Validator[0]: NodeID-111111111111111111116DBWJs, 1\n" +
@@ -480,8 +448,7 @@ func TestSetAddCallback(t *testing.T) {
 			callCount++
 		},
 	})
-	err = s.Add(nodeID0, pk0, txID0, weight0)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID0, pk0, txID0, weight0))
 	require.Equal(1, callCount)
 }
 
@@ -494,8 +461,7 @@ func TestSetAddWeightCallback(t *testing.T) {
 	weight1 := uint64(93)
 
 	s := NewSet()
-	err := s.Add(nodeID0, nil, txID0, weight0)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID0, nil, txID0, weight0))
 
 	callCount := 0
 	s.RegisterCallbackListener(&callbackListener{
@@ -514,8 +480,7 @@ func TestSetAddWeightCallback(t *testing.T) {
 			callCount++
 		},
 	})
-	err = s.AddWeight(nodeID0, weight1)
-	require.NoError(err)
+	require.NoError(s.AddWeight(nodeID0, weight1))
 	require.Equal(2, callCount)
 }
 
@@ -528,8 +493,7 @@ func TestSetRemoveWeightCallback(t *testing.T) {
 	weight1 := uint64(92)
 
 	s := NewSet()
-	err := s.Add(nodeID0, nil, txID0, weight0)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID0, nil, txID0, weight0))
 
 	callCount := 0
 	s.RegisterCallbackListener(&callbackListener{
@@ -548,8 +512,7 @@ func TestSetRemoveWeightCallback(t *testing.T) {
 			callCount++
 		},
 	})
-	err = s.RemoveWeight(nodeID0, weight1)
-	require.NoError(err)
+	require.NoError(s.RemoveWeight(nodeID0, weight1))
 	require.Equal(2, callCount)
 }
 
@@ -561,8 +524,7 @@ func TestSetValidatorRemovedCallback(t *testing.T) {
 	weight0 := uint64(93)
 
 	s := NewSet()
-	err := s.Add(nodeID0, nil, txID0, weight0)
-	require.NoError(err)
+	require.NoError(s.Add(nodeID0, nil, txID0, weight0))
 
 	callCount := 0
 	s.RegisterCallbackListener(&callbackListener{
@@ -580,7 +542,6 @@ func TestSetValidatorRemovedCallback(t *testing.T) {
 			callCount++
 		},
 	})
-	err = s.RemoveWeight(nodeID0, weight0)
-	require.NoError(err)
+	require.NoError(s.RemoveWeight(nodeID0, weight0))
 	require.Equal(2, callCount)
 }
diff --git a/staking/tls_test.go b/staking/tls_test.go
index bcab2c98b45c..2282090b4c8e 100644
--- a/staking/tls_test.go
+++ b/staking/tls_test.go
@@ -27,6 +27,5 @@ func TestMakeKeys(t *testing.T) {
 	sig, err := cert.PrivateKey.(crypto.Signer).Sign(rand.Reader, msgHash, crypto.SHA256)
 	require.NoError(err)
 
-	err = cert.Leaf.CheckSignature(cert.Leaf.SignatureAlgorithm, msg, sig)
-	require.NoError(err)
+	require.NoError(cert.Leaf.CheckSignature(cert.Leaf.SignatureAlgorithm, msg, sig))
 }
diff --git a/utils/beacon/set_test.go b/utils/beacon/set_test.go
index da396631a984..2d4d3d7f240d 100644
--- a/utils/beacon/set_test.go
+++ b/utils/beacon/set_test.go
@@ -46,8 +46,7 @@ func TestSet(t *testing.T) {
 	len := s.Len()
 	require.Zero(len)
 
-	err := s.Add(b0)
-	require.NoError(err)
+	require.NoError(s.Add(b0))
 
 	idsArg = s.IDsArg()
 	require.Equal("NodeID-111111111111111111116DBWJs", idsArg)
@@ -56,7 +55,7 @@ func TestSet(t *testing.T) {
 	len = s.Len()
 	require.Equal(1, len)
 
-	err = s.Add(b0)
+	err := s.Add(b0)
 	require.ErrorIs(err, errDuplicateID)
 
 	idsArg = s.IDsArg()
@@ -66,8 +65,7 @@ func TestSet(t *testing.T) {
 	len = s.Len()
 	require.Equal(1, len)
 
-	err = s.Add(b1)
-	require.NoError(err)
+	require.NoError(s.Add(b1))
 
 	idsArg = s.IDsArg()
 	require.Equal("NodeID-111111111111111111116DBWJs,NodeID-6HgC8KRBEhXYbF4riJyJFLSHt37UNuRt", idsArg)
@@ -76,8 +74,7 @@ func TestSet(t *testing.T) {
 	len = s.Len()
 	require.Equal(2, len)
 
-	err = s.Add(b2)
-	require.NoError(err)
+	require.NoError(s.Add(b2))
 
 	idsArg = s.IDsArg()
 	require.Equal("NodeID-111111111111111111116DBWJs,NodeID-6HgC8KRBEhXYbF4riJyJFLSHt37UNuRt,NodeID-BaMPFdqMUQ46BV8iRcwbVfsam55kMqcp", idsArg)
@@ -86,8 +83,7 @@ func TestSet(t *testing.T) {
 	len = s.Len()
 	require.Equal(3, len)
 
-	err = s.RemoveByID(b0.ID())
-	require.NoError(err)
+	require.NoError(s.RemoveByID(b0.ID()))
 
 	idsArg = s.IDsArg()
 	require.Equal("NodeID-BaMPFdqMUQ46BV8iRcwbVfsam55kMqcp,NodeID-6HgC8KRBEhXYbF4riJyJFLSHt37UNuRt", idsArg)
@@ -96,8 +92,7 @@ func TestSet(t *testing.T) {
 	len = s.Len()
 	require.Equal(2, len)
 
-	err = s.RemoveByIP(b1.IP())
-	require.NoError(err)
+	require.NoError(s.RemoveByIP(b1.IP()))
 
 	idsArg = s.IDsArg()
 	require.Equal("NodeID-BaMPFdqMUQ46BV8iRcwbVfsam55kMqcp", idsArg)
diff --git a/utils/crypto/secp256k1/secp256k1_test.go b/utils/crypto/secp256k1/secp256k1_test.go
index 8f5e3879d38d..b9c47ac4e8b9 100644
--- a/utils/crypto/secp256k1/secp256k1_test.go
+++ b/utils/crypto/secp256k1/secp256k1_test.go
@@ -115,8 +115,7 @@ func TestPrivateKeySECP256K1RUnmarshalJSON(t *testing.T) {
 	require.NoError(err)
 
 	key2 := PrivateKey{}
-	err = key2.UnmarshalJSON(keyJSON)
-	require.NoError(err)
+	require.NoError(key2.UnmarshalJSON(keyJSON))
 	require.Equal(key.PublicKey(), key2.PublicKey())
 }
 
diff --git a/utils/profiler/profiler_test.go b/utils/profiler/profiler_test.go
index 8f04c940532a..2d7d864aca62 100644
--- a/utils/profiler/profiler_test.go
+++ b/utils/profiler/profiler_test.go
@@ -19,13 +19,11 @@ func TestProfiler(t *testing.T) {
 	p := New(dir)
 
 	// Test Start and Stop CPU Profiler
-	err := p.StartCPUProfiler()
-	require.NoError(err)
+	require.NoError(p.StartCPUProfiler())
 
-	err = p.StopCPUProfiler()
-	require.NoError(err)
+	require.NoError(p.StopCPUProfiler())
 
-	_, err = os.Stat(filepath.Join(dir, cpuProfileFile))
+	_, err := os.Stat(filepath.Join(dir, cpuProfileFile))
 	require.NoError(err)
 
 	// Test Stop CPU Profiler without it running
@@ -33,15 +31,13 @@ func TestProfiler(t *testing.T) {
 	require.ErrorIs(err, errCPUProfilerNotRunning)
 
 	// Test Memory Profiler
-	err = p.MemoryProfile()
-	require.NoError(err)
+	require.NoError(p.MemoryProfile())
 
 	_, err = os.Stat(filepath.Join(dir, memProfileFile))
 	require.NoError(err)
 
 	// Test Lock Profiler
-	err = p.LockProfile()
-	require.NoError(err)
+	require.NoError(p.LockProfile())
 
 	_, err = os.Stat(filepath.Join(dir, lockProfileFile))
 	require.NoError(err)
diff --git a/utils/sampler/weighted_heap_test.go b/utils/sampler/weighted_heap_test.go
index 098f431b7340..4d409198ce57 100644
--- a/utils/sampler/weighted_heap_test.go
+++ b/utils/sampler/weighted_heap_test.go
@@ -14,8 +14,7 @@ func TestWeightedHeapInitialize(t *testing.T) {
 
 	h := weightedHeap{}
 
-	err := h.Initialize([]uint64{2, 2, 1, 3, 3, 1, 3})
-	require.NoError(err)
+	require.NoError(h.Initialize([]uint64{2, 2, 1, 3, 3, 1, 3}))
 
 	expectedOrdering := []int{3, 4, 6, 0, 1, 2, 5}
 	for i, elem := range h.heap {
diff --git a/utils/sampler/weighted_test.go b/utils/sampler/weighted_test.go
index 5bd29fff79f1..aba782ea3f6b 100644
--- a/utils/sampler/weighted_test.go
+++ b/utils/sampler/weighted_test.go
@@ -94,16 +94,14 @@ func WeightedInitializeOverflowTest(t *testing.T, s Weighted) {
 }
 
 func WeightedOutOfRangeTest(t *testing.T, s Weighted) {
-	err := s.Initialize([]uint64{1})
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize([]uint64{1}))
 
-	_, err = s.Sample(1)
+	_, err := s.Sample(1)
 	require.ErrorIs(t, err, ErrOutOfRange)
 }
 
 func WeightedSingletonTest(t *testing.T, s Weighted) {
-	err := s.Initialize([]uint64{1})
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize([]uint64{1}))
 
 	index, err := s.Sample(0)
 	require.NoError(t, err)
@@ -111,8 +109,7 @@ func WeightedSingletonTest(t *testing.T, s Weighted) {
 }
 
 func WeightedWithZeroTest(t *testing.T, s Weighted) {
-	err := s.Initialize([]uint64{0, 1})
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize([]uint64{0, 1}))
 
 	index, err := s.Sample(0)
 	require.NoError(t, err)
@@ -120,8 +117,7 @@ func WeightedWithZeroTest(t *testing.T, s Weighted) {
 }
 
 func WeightedDistributionTest(t *testing.T, s Weighted) {
-	err := s.Initialize([]uint64{1, 1, 2, 3, 4})
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize([]uint64{1, 1, 2, 3, 4}))
 
 	counts := make([]int, 5)
 	for i := uint64(0); i < 11; i++ {
diff --git a/utils/sampler/weighted_without_replacement_test.go b/utils/sampler/weighted_without_replacement_test.go
index a73cac19071a..3bba30870940 100644
--- a/utils/sampler/weighted_without_replacement_test.go
+++ b/utils/sampler/weighted_without_replacement_test.go
@@ -95,10 +95,9 @@ func WeightedWithoutReplacementOutOfRangeTest(
 	t *testing.T,
 	s WeightedWithoutReplacement,
 ) {
-	err := s.Initialize([]uint64{1})
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize([]uint64{1}))
 
-	_, err = s.Sample(2)
+	_, err := s.Sample(2)
 	require.ErrorIs(t, err, ErrOutOfRange)
 }
 
@@ -106,8 +105,7 @@ func WeightedWithoutReplacementEmptyWithoutWeightTest(
 	t *testing.T,
 	s WeightedWithoutReplacement,
 ) {
-	err := s.Initialize(nil)
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize(nil))
 
 	indices, err := s.Sample(0)
 	require.NoError(t, err)
@@ -118,8 +116,7 @@ func WeightedWithoutReplacementEmptyTest(
 	t *testing.T,
 	s WeightedWithoutReplacement,
 ) {
-	err := s.Initialize([]uint64{1})
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize([]uint64{1}))
 
 	indices, err := s.Sample(0)
 	require.NoError(t, err)
@@ -130,8 +127,7 @@ func WeightedWithoutReplacementSingletonTest(
 	t *testing.T,
 	s WeightedWithoutReplacement,
 ) {
-	err := s.Initialize([]uint64{1})
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize([]uint64{1}))
 
 	indices, err := s.Sample(1)
 	require.NoError(t, err)
@@ -142,8 +138,7 @@ func WeightedWithoutReplacementWithZeroTest(
 	t *testing.T,
 	s WeightedWithoutReplacement,
 ) {
-	err := s.Initialize([]uint64{0, 1})
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize([]uint64{0, 1}))
 
 	indices, err := s.Sample(1)
 	require.NoError(t, err)
@@ -159,8 +154,7 @@ func WeightedWithoutReplacementDistributionTest(
 	t *testing.T,
 	s WeightedWithoutReplacement,
 ) {
-	err := s.Initialize([]uint64{1, 1, 2})
-	require.NoError(t, err)
+	require.NoError(t, s.Initialize([]uint64{1, 1, 2}))
 
 	indices, err := s.Sample(4)
 	require.NoError(t, err)
diff --git a/utils/set/set_test.go b/utils/set/set_test.go
index a0ae3eb9de1e..603c46b5a35e 100644
--- a/utils/set/set_test.go
+++ b/utils/set/set_test.go
@@ -145,8 +145,7 @@ func TestSetUnmarshalJSON(t *testing.T) {
 	require := require.New(t)
 	set := Set[int]{}
 	{
-		err := set.UnmarshalJSON([]byte("[]"))
-		require.NoError(err)
+		require.NoError(set.UnmarshalJSON([]byte("[]")))
 		require.Empty(set)
 	}
 	id1, id2 := 1, 2
@@ -155,29 +154,25 @@ func TestSetUnmarshalJSON(t *testing.T) {
 	id2JSON, err := json.Marshal(id2)
 	require.NoError(err)
 	{
-		err := set.UnmarshalJSON([]byte(fmt.Sprintf("[%s]", string(id1JSON))))
-		require.NoError(err)
+		require.NoError(set.UnmarshalJSON([]byte(fmt.Sprintf("[%s]", string(id1JSON)))))
 		require.Len(set, 1)
 		require.Contains(set, id1)
 	}
 	{
-		err := set.UnmarshalJSON([]byte(fmt.Sprintf("[%s,%s]", string(id1JSON), string(id2JSON))))
-		require.NoError(err)
+		require.NoError(set.UnmarshalJSON([]byte(fmt.Sprintf("[%s,%s]", string(id1JSON), string(id2JSON)))))
 		require.Len(set, 2)
 		require.Contains(set, id1)
 		require.Contains(set, id2)
 	}
 	{
-		err := set.UnmarshalJSON([]byte(fmt.Sprintf("[%d,%d,%d]", 3, 4, 5)))
-		require.NoError(err)
+		require.NoError(set.UnmarshalJSON([]byte(fmt.Sprintf("[%d,%d,%d]", 3, 4, 5))))
 		require.Len(set, 3)
 		require.Contains(set, 3)
 		require.Contains(set, 4)
 		require.Contains(set, 5)
 	}
 	{
-		err := set.UnmarshalJSON([]byte(fmt.Sprintf("[%d,%d,%d, %d]", 3, 4, 5, 3)))
-		require.NoError(err)
+		require.NoError(set.UnmarshalJSON([]byte(fmt.Sprintf("[%d,%d,%d, %d]", 3, 4, 5, 3))))
 		require.Len(set, 3)
 		require.Contains(set, 3)
 		require.Contains(set, 4)
@@ -186,10 +181,8 @@ func TestSetUnmarshalJSON(t *testing.T) {
 	{
 		set1 := Set[int]{}
 		set2 := Set[int]{}
-		err := set1.UnmarshalJSON([]byte(fmt.Sprintf("[%s,%s]", string(id1JSON), string(id2JSON))))
-		require.NoError(err)
-		err = set2.UnmarshalJSON([]byte(fmt.Sprintf("[%s,%s]", string(id2JSON), string(id1JSON))))
-		require.NoError(err)
+		require.NoError(set1.UnmarshalJSON([]byte(fmt.Sprintf("[%s,%s]", string(id1JSON), string(id2JSON)))))
+		require.NoError(set2.UnmarshalJSON([]byte(fmt.Sprintf("[%s,%s]", string(id2JSON), string(id1JSON)))))
 		require.Equal(set1, set2)
 	}
 }
diff --git a/vms/avm/blocks/builder/builder_test.go b/vms/avm/blocks/builder/builder_test.go
index a1501a0cddb0..2a504cd9255a 100644
--- a/vms/avm/blocks/builder/builder_test.go
+++ b/vms/avm/blocks/builder/builder_test.go
@@ -510,8 +510,7 @@ func TestBlockBuilderAddLocalTx(t *testing.T) {
 	// add a tx to the mempool
 	tx := transactions[0]
 	txID := tx.ID()
-	err = mempool.Add(tx)
-	require.NoError(err)
+	require.NoError(mempool.Add(tx))
 
 	has := mempool.Has(txID)
 	require.True(has)
diff --git a/vms/avm/blocks/executor/block_test.go b/vms/avm/blocks/executor/block_test.go
index 781ede461ea2..d58f78825caa 100644
--- a/vms/avm/blocks/executor/block_test.go
+++ b/vms/avm/blocks/executor/block_test.go
@@ -961,8 +961,7 @@ func TestBlockReject(t *testing.T) {
 			defer ctrl.Finish()
 
 			b := tt.blockFunc(ctrl)
-			err := b.Reject(context.Background())
-			require.NoError(err)
+			require.NoError(b.Reject(context.Background()))
 			require.True(b.rejected)
 			_, ok := b.manager.blkIDToState[b.ID()]
 			require.False(ok)
diff --git a/vms/avm/blocks/executor/manager_test.go b/vms/avm/blocks/executor/manager_test.go
index f5c43d1f59f4..4e7d9e3c466c 100644
--- a/vms/avm/blocks/executor/manager_test.go
+++ b/vms/avm/blocks/executor/manager_test.go
@@ -317,8 +317,7 @@ func TestVerifyUniqueInputs(t *testing.T) {
 	// Case: No inputs
 	{
 		m := &manager{}
-		err := m.VerifyUniqueInputs(ids.GenerateTestID(), set.Set[ids.ID]{})
-		require.NoError(err)
+		require.NoError(m.VerifyUniqueInputs(ids.GenerateTestID(), set.Set[ids.ID]{}))
 	}
 
 	// blk0 is blk1's parent
@@ -344,6 +343,5 @@ func TestVerifyUniqueInputs(t *testing.T) {
 	err := m.VerifyUniqueInputs(blk1ID, set.Set[ids.ID]{inputID: struct{}{}})
 	require.ErrorIs(err, ErrConflictingParentTxs)
 
-	err = m.VerifyUniqueInputs(blk1ID, set.Set[ids.ID]{ids.GenerateTestID(): struct{}{}})
-	require.NoError(err)
+	require.NoError(m.VerifyUniqueInputs(blk1ID, set.Set[ids.ID]{ids.GenerateTestID(): struct{}{}}))
 }
diff --git a/vms/avm/index_test.go b/vms/avm/index_test.go
index 5ce7af2ae836..22d4d13fc9fc 100644
--- a/vms/avm/index_test.go
+++ b/vms/avm/index_test.go
@@ -114,8 +114,7 @@ func TestIndexTransaction_Ordered(t *testing.T) {
 		}
 
 		// index the transaction
-		err := vm.addressTxsIndexer.Accept(uniqueParsedTX.ID(), inputUTXOs, uniqueParsedTX.UTXOs())
-		require.NoError(t, err)
+		require.NoError(t, vm.addressTxsIndexer.Accept(uniqueParsedTX.ID(), inputUTXOs, uniqueParsedTX.UTXOs()))
 	}
 
 	// ensure length is 5
@@ -204,8 +203,7 @@ func TestIndexTransaction_MultipleTransactions(t *testing.T) {
 		}
 
 		// index the transaction
-		err := vm.addressTxsIndexer.Accept(uniqueParsedTX.ID(), inputUTXOs, uniqueParsedTX.UTXOs())
-		require.NoError(t, err)
+		require.NoError(t, vm.addressTxsIndexer.Accept(uniqueParsedTX.ID(), inputUTXOs, uniqueParsedTX.UTXOs()))
 	}
 
 	// ensure length is same as keys length
@@ -274,9 +272,7 @@ func TestIndexTransaction_MultipleAddresses(t *testing.T) {
 	}
 
 	// index the transaction
-	err := vm.addressTxsIndexer.Accept(tx.ID(), inputUTXOs, tx.UTXOs())
-	require.NoError(t, err)
-	require.NoError(t, err)
+	require.NoError(t, vm.addressTxsIndexer.Accept(tx.ID(), inputUTXOs, tx.UTXOs()))
 
 	assertIndexedTX(t, vm.db, uint64(0), addr, txAssetID.ID, tx.ID())
 	assertLatestIdx(t, vm.db, addr, txAssetID.ID, 1)
@@ -357,8 +353,7 @@ func TestIndexTransaction_UnorderedWrites(t *testing.T) {
 		}
 
 		// index the transaction, NOT calling Accept(ids.ID) method
-		err := vm.addressTxsIndexer.Accept(uniqueParsedTX.ID(), inputUTXOs, uniqueParsedTX.UTXOs())
-		require.NoError(t, err)
+		require.NoError(t, vm.addressTxsIndexer.Accept(uniqueParsedTX.ID(), inputUTXOs, uniqueParsedTX.UTXOs()))
 	}
 
 	// ensure length is same as keys length
@@ -608,17 +603,14 @@ func setupTestTxsInDB(t *testing.T, db *versiondb.Database, address ids.ShortID,
 	binary.BigEndian.PutUint64(idxBytes, idx)
 	for _, txID := range testTxs {
 		txID := txID
-		err := assetPrefixDB.Put(idxBytes, txID[:])
-		require.NoError(t, err)
+		require.NoError(t, assetPrefixDB.Put(idxBytes, txID[:]))
 		idx++
 		binary.BigEndian.PutUint64(idxBytes, idx)
 	}
 	_, err := db.CommitBatch()
 	require.NoError(t, err)
 
-	err = assetPrefixDB.Put([]byte("idx"), idxBytes)
-	require.NoError(t, err)
-	err = db.Commit()
-	require.NoError(t, err)
+	require.NoError(t, assetPrefixDB.Put([]byte("idx"), idxBytes))
+	require.NoError(t, db.Commit())
 	return testTxs
 }
diff --git a/vms/avm/network/network_test.go b/vms/avm/network/network_test.go
index 0e0cb76aa34e..351975063ab6 100644
--- a/vms/avm/network/network_test.go
+++ b/vms/avm/network/network_test.go
@@ -158,8 +158,7 @@ func TestNetworkAppGossip(t *testing.T) {
 				tt.mempoolFunc(ctrl),
 				tt.appSenderFunc(ctrl),
 			)
-			err = n.AppGossip(context.Background(), ids.GenerateTestNodeID(), tt.msgBytesFunc())
-			require.NoError(err)
+			require.NoError(n.AppGossip(context.Background(), ids.GenerateTestNodeID(), tt.msgBytesFunc()))
 		})
 	}
 }
diff --git a/vms/avm/pubsub_filterer_test.go b/vms/avm/pubsub_filterer_test.go
index 9d5fb5c231c7..95f4fc3cd229 100644
--- a/vms/avm/pubsub_filterer_test.go
+++ b/vms/avm/pubsub_filterer_test.go
@@ -42,8 +42,7 @@ func TestFilter(t *testing.T) {
 	addrBytes := addrID[:]
 
 	fp := pubsub.NewFilterParam()
-	err := fp.Add(addrBytes)
-	require.NoError(err)
+	require.NoError(fp.Add(addrBytes))
 
 	parser := NewPubSubFilterer(&tx)
 	fr, _ := parser.Filter([]pubsub.Filter{&mockFilter{addr: addrBytes}})
diff --git a/vms/avm/service_test.go b/vms/avm/service_test.go
index 0ee3303ff358..9203d3e8a94b 100644
--- a/vms/avm/service_test.go
+++ b/vms/avm/service_test.go
@@ -310,8 +310,7 @@ func TestServiceGetBalanceStrict(t *testing.T) {
 		IncludePartial: true,
 	}
 	balanceReply := &GetBalanceReply{}
-	err = s.GetBalance(nil, balanceArgs, balanceReply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetBalance(nil, balanceArgs, balanceReply))
 	// The balance should include the UTXO since it is partly owned by [addr]
 	require.Equal(t, uint64(1337), uint64(balanceReply.Balance))
 	require.Len(t, balanceReply.UTXOIDs, 1, "should have only returned 1 utxoID")
@@ -322,8 +321,7 @@ func TestServiceGetBalanceStrict(t *testing.T) {
 		AssetID: assetID.String(),
 	}
 	balanceReply = &GetBalanceReply{}
-	err = s.GetBalance(nil, balanceArgs, balanceReply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetBalance(nil, balanceArgs, balanceReply))
 	// The balance should not include the UTXO since it is only partly owned by [addr]
 	require.Zero(t, balanceReply.Balance)
 	require.Empty(t, balanceReply.UTXOIDs)
@@ -355,8 +353,7 @@ func TestServiceGetBalanceStrict(t *testing.T) {
 		IncludePartial: true,
 	}
 	balanceReply = &GetBalanceReply{}
-	err = s.GetBalance(nil, balanceArgs, balanceReply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetBalance(nil, balanceArgs, balanceReply))
 	// The balance should include the UTXO since it is partly owned by [addr]
 	require.Equal(t, uint64(1337+1337), uint64(balanceReply.Balance))
 	require.Len(t, balanceReply.UTXOIDs, 2, "should have only returned 2 utxoIDs")
@@ -367,8 +364,7 @@ func TestServiceGetBalanceStrict(t *testing.T) {
 		AssetID: assetID.String(),
 	}
 	balanceReply = &GetBalanceReply{}
-	err = s.GetBalance(nil, balanceArgs, balanceReply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetBalance(nil, balanceArgs, balanceReply))
 	// The balance should not include the UTXO since it is only partly owned by [addr]
 	require.Zero(t, balanceReply.Balance)
 	require.Empty(t, balanceReply.UTXOIDs)
@@ -402,8 +398,7 @@ func TestServiceGetBalanceStrict(t *testing.T) {
 		IncludePartial: true,
 	}
 	balanceReply = &GetBalanceReply{}
-	err = s.GetBalance(nil, balanceArgs, balanceReply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetBalance(nil, balanceArgs, balanceReply))
 	// The balance should include the UTXO since it is partly owned by [addr]
 	require.Equal(t, uint64(1337*3), uint64(balanceReply.Balance))
 	require.Len(t, balanceReply.UTXOIDs, 3, "should have returned 3 utxoIDs")
@@ -414,8 +409,7 @@ func TestServiceGetBalanceStrict(t *testing.T) {
 		AssetID: assetID.String(),
 	}
 	balanceReply = &GetBalanceReply{}
-	err = s.GetBalance(nil, balanceArgs, balanceReply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetBalance(nil, balanceArgs, balanceReply))
 	// The balance should not include the UTXO since it is only partly owned by [addr]
 	require.Zero(t, balanceReply.Balance)
 	require.Empty(t, balanceReply.UTXOIDs)
@@ -450,16 +444,14 @@ func TestServiceGetTxs(t *testing.T) {
 		AssetID:     assetID.String(),
 	}
 	getTxsReply := &GetAddressTxsReply{}
-	err = s.GetAddressTxs(nil, getTxsArgs, getTxsReply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAddressTxs(nil, getTxsArgs, getTxsReply))
 	require.Len(t, getTxsReply.TxIDs, 10)
 	require.Equal(t, getTxsReply.TxIDs, testTxs[:10])
 
 	// get the second page
 	getTxsArgs.Cursor = getTxsReply.Cursor
 	getTxsReply = &GetAddressTxsReply{}
-	err = s.GetAddressTxs(nil, getTxsArgs, getTxsReply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAddressTxs(nil, getTxsArgs, getTxsReply))
 	require.Len(t, getTxsReply.TxIDs, 10)
 	require.Equal(t, getTxsReply.TxIDs, testTxs[10:20])
 }
@@ -505,8 +497,7 @@ func TestServiceGetAllBalances(t *testing.T) {
 		IncludePartial: true,
 	}
 	reply := &GetAllBalancesReply{}
-	err = s.GetAllBalances(nil, balanceArgs, reply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAllBalances(nil, balanceArgs, reply))
 	// The balance should include the UTXO since it is partly owned by [addr]
 	require.Len(t, reply.Balances, 1)
 	require.Equal(t, assetID.String(), reply.Balances[0].AssetID)
@@ -517,8 +508,7 @@ func TestServiceGetAllBalances(t *testing.T) {
 		JSONAddress: api.JSONAddress{Address: addrStr},
 	}
 	reply = &GetAllBalancesReply{}
-	err = s.GetAllBalances(nil, balanceArgs, reply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAllBalances(nil, balanceArgs, reply))
 	require.Empty(t, reply.Balances)
 
 	// A UTXO with a 1 out of 2 multisig
@@ -547,8 +537,7 @@ func TestServiceGetAllBalances(t *testing.T) {
 		IncludePartial: true,
 	}
 	reply = &GetAllBalancesReply{}
-	err = s.GetAllBalances(nil, balanceArgs, reply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAllBalances(nil, balanceArgs, reply))
 	// The balance should include the UTXO since it is partly owned by [addr]
 	require.Len(t, reply.Balances, 1)
 	require.Equal(t, assetID.String(), reply.Balances[0].AssetID)
@@ -559,8 +548,7 @@ func TestServiceGetAllBalances(t *testing.T) {
 		JSONAddress: api.JSONAddress{Address: addrStr},
 	}
 	reply = &GetAllBalancesReply{}
-	err = s.GetAllBalances(nil, balanceArgs, reply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAllBalances(nil, balanceArgs, reply))
 	// The balance should not include the UTXO since it is only partly owned by [addr]
 	require.Empty(t, reply.Balances)
 
@@ -592,8 +580,7 @@ func TestServiceGetAllBalances(t *testing.T) {
 		IncludePartial: true,
 	}
 	reply = &GetAllBalancesReply{}
-	err = s.GetAllBalances(nil, balanceArgs, reply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAllBalances(nil, balanceArgs, reply))
 	// The balance should include the UTXO since it is partly owned by [addr]
 	// The balance should include the UTXO since it is partly owned by [addr]
 	require.Len(t, reply.Balances, 1)
@@ -604,8 +591,7 @@ func TestServiceGetAllBalances(t *testing.T) {
 		JSONAddress: api.JSONAddress{Address: addrStr},
 	}
 	reply = &GetAllBalancesReply{}
-	err = s.GetAllBalances(nil, balanceArgs, reply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAllBalances(nil, balanceArgs, reply))
 	// The balance should not include the UTXO since it is only partly owned by [addr]
 	require.Empty(t, reply.Balances)
 
@@ -635,8 +621,7 @@ func TestServiceGetAllBalances(t *testing.T) {
 		IncludePartial: true,
 	}
 	reply = &GetAllBalancesReply{}
-	err = s.GetAllBalances(nil, balanceArgs, reply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAllBalances(nil, balanceArgs, reply))
 	// The balance should include the UTXO since it is partly owned by [addr]
 	require.Len(t, reply.Balances, 2)
 	gotAssetIDs := []string{reply.Balances[0].AssetID, reply.Balances[1].AssetID}
@@ -651,36 +636,28 @@ func TestServiceGetAllBalances(t *testing.T) {
 		JSONAddress: api.JSONAddress{Address: addrStr},
 	}
 	reply = &GetAllBalancesReply{}
-	err = s.GetAllBalances(nil, balanceArgs, reply)
-	require.NoError(t, err)
+	require.NoError(t, s.GetAllBalances(nil, balanceArgs, reply))
 	// The balance should include the UTXO since it is partly owned by [addr]
 	require.Empty(t, reply.Balances)
 }
 
 func TestServiceGetTx(t *testing.T) {
+	require := require.New(t)
 	_, vm, s, _, genesisTx := setup(t, true)
 	defer func() {
-		if err := vm.Shutdown(context.Background()); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(vm.Shutdown(context.Background()))
 		vm.ctx.Lock.Unlock()
 	}()
 
 	txID := genesisTx.ID()
 
 	reply := api.GetTxReply{}
-	err := s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID: txID,
-	}, &reply)
-	require.NoError(t, err)
-	if err != nil {
-		t.Fatal(err)
-	}
+	}, &reply))
 	txBytes, err := formatting.Decode(reply.Encoding, reply.Tx.(string))
-	if err != nil {
-		t.Fatal(err)
-	}
-	require.Equal(t, genesisTx.Bytes(), txBytes, "Wrong tx returned from service.GetTx")
+	require.NoError(err)
+	require.Equal(genesisTx.Bytes(), txBytes)
 }
 
 func TestServiceGetTxJSON_BaseTx(t *testing.T) {
@@ -709,11 +686,10 @@ func TestServiceGetTxJSON_BaseTx(t *testing.T) {
 	require.NoError(txs[0].Accept(context.Background()))
 
 	reply := api.GetTxReply{}
-	err = s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID:     txID,
 		Encoding: formatting.JSON,
-	}, &reply)
-	require.NoError(err)
+	}, &reply))
 
 	require.Equal(reply.Encoding, formatting.JSON)
 	jsonTxBytes, err := stdjson.Marshal(reply.Tx)
@@ -751,11 +727,10 @@ func TestServiceGetTxJSON_ExportTx(t *testing.T) {
 	require.NoError(txs[0].Accept(context.Background()))
 
 	reply := api.GetTxReply{}
-	err = s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID:     txID,
 		Encoding: formatting.JSON,
-	}, &reply)
-	require.NoError(err)
+	}, &reply))
 
 	require.Equal(reply.Encoding, formatting.JSON)
 	jsonTxBytes, err := stdjson.Marshal(reply.Tx)
@@ -783,7 +758,7 @@ func TestServiceGetTxJSON_CreateAssetTx(t *testing.T) {
 
 	genesisBytes := BuildGenesisTest(t)
 	issuer := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		baseDBManager,
@@ -806,8 +781,7 @@ func TestServiceGetTxJSON_CreateAssetTx(t *testing.T) {
 			},
 		},
 		&common.SenderTest{T: t},
-	)
-	require.NoError(err)
+	))
 	vm.batchTimeout = 0
 
 	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
@@ -829,11 +803,10 @@ func TestServiceGetTxJSON_CreateAssetTx(t *testing.T) {
 
 	reply := api.GetTxReply{}
 	s := &Service{vm: vm}
-	err = s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID:     txID,
 		Encoding: formatting.JSON,
-	}, &reply)
-	require.NoError(err)
+	}, &reply))
 
 	require.Equal(reply.Encoding, formatting.JSON)
 	jsonTxBytes, err := stdjson.Marshal(reply.Tx)
@@ -862,7 +835,7 @@ func TestServiceGetTxJSON_OperationTxWithNftxMintOp(t *testing.T) {
 
 	genesisBytes := BuildGenesisTest(t)
 	issuer := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		baseDBManager,
@@ -885,8 +858,7 @@ func TestServiceGetTxJSON_OperationTxWithNftxMintOp(t *testing.T) {
 			},
 		},
 		&common.SenderTest{T: t},
-	)
-	require.NoError(err)
+	))
 	vm.batchTimeout = 0
 
 	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
@@ -894,12 +866,11 @@ func TestServiceGetTxJSON_OperationTxWithNftxMintOp(t *testing.T) {
 
 	key := keys[0]
 	createAssetTx := newAvaxCreateAssetTxWithOutputs(t, vm)
-	_, err = vm.IssueTx(createAssetTx.Bytes())
+	_, err := vm.IssueTx(createAssetTx.Bytes())
 	require.NoError(err)
 
 	mintNFTTx := buildOperationTxWithOp(buildNFTxMintOp(createAssetTx, key, 2, 1))
-	err = mintNFTTx.SignNFTFx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}})
-	require.NoError(err)
+	require.NoError(mintNFTTx.SignNFTFx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}}))
 
 	txID, err := vm.IssueTx(mintNFTTx.Bytes())
 	require.NoError(err)
@@ -917,11 +888,10 @@ func TestServiceGetTxJSON_OperationTxWithNftxMintOp(t *testing.T) {
 
 	reply := api.GetTxReply{}
 	s := &Service{vm: vm}
-	err = s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID:     txID,
 		Encoding: formatting.JSON,
-	}, &reply)
-	require.NoError(err)
+	}, &reply))
 
 	require.Equal(reply.Encoding, formatting.JSON)
 	jsonTxBytes, err := stdjson.Marshal(reply.Tx)
@@ -954,7 +924,7 @@ func TestServiceGetTxJSON_OperationTxWithMultipleNftxMintOp(t *testing.T) {
 
 	genesisBytes := BuildGenesisTest(t)
 	issuer := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		baseDBManager,
@@ -977,8 +947,7 @@ func TestServiceGetTxJSON_OperationTxWithMultipleNftxMintOp(t *testing.T) {
 			},
 		},
 		&common.SenderTest{T: t},
-	)
-	require.NoError(err)
+	))
 	vm.batchTimeout = 0
 
 	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
@@ -986,15 +955,14 @@ func TestServiceGetTxJSON_OperationTxWithMultipleNftxMintOp(t *testing.T) {
 
 	key := keys[0]
 	createAssetTx := newAvaxCreateAssetTxWithOutputs(t, vm)
-	_, err = vm.IssueTx(createAssetTx.Bytes())
+	_, err := vm.IssueTx(createAssetTx.Bytes())
 	require.NoError(err)
 
 	mintOp1 := buildNFTxMintOp(createAssetTx, key, 2, 1)
 	mintOp2 := buildNFTxMintOp(createAssetTx, key, 3, 2)
 	mintNFTTx := buildOperationTxWithOp(mintOp1, mintOp2)
 
-	err = mintNFTTx.SignNFTFx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}, {key}})
-	require.NoError(err)
+	require.NoError(mintNFTTx.SignNFTFx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}, {key}}))
 
 	txID, err := vm.IssueTx(mintNFTTx.Bytes())
 	require.NoError(err)
@@ -1012,11 +980,10 @@ func TestServiceGetTxJSON_OperationTxWithMultipleNftxMintOp(t *testing.T) {
 
 	reply := api.GetTxReply{}
 	s := &Service{vm: vm}
-	err = s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID:     txID,
 		Encoding: formatting.JSON,
-	}, &reply)
-	require.NoError(err)
+	}, &reply))
 
 	require.Equal(reply.Encoding, formatting.JSON)
 	jsonTxBytes, err := stdjson.Marshal(reply.Tx)
@@ -1048,7 +1015,7 @@ func TestServiceGetTxJSON_OperationTxWithSecpMintOp(t *testing.T) {
 
 	genesisBytes := BuildGenesisTest(t)
 	issuer := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		baseDBManager,
@@ -1071,8 +1038,7 @@ func TestServiceGetTxJSON_OperationTxWithSecpMintOp(t *testing.T) {
 			},
 		},
 		&common.SenderTest{T: t},
-	)
-	require.NoError(err)
+	))
 	vm.batchTimeout = 0
 
 	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
@@ -1080,12 +1046,11 @@ func TestServiceGetTxJSON_OperationTxWithSecpMintOp(t *testing.T) {
 
 	key := keys[0]
 	createAssetTx := newAvaxCreateAssetTxWithOutputs(t, vm)
-	_, err = vm.IssueTx(createAssetTx.Bytes())
+	_, err := vm.IssueTx(createAssetTx.Bytes())
 	require.NoError(err)
 
 	mintSecpOpTx := buildOperationTxWithOp(buildSecpMintOp(createAssetTx, key, 0))
-	err = mintSecpOpTx.SignSECP256K1Fx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}})
-	require.NoError(err)
+	require.NoError(mintSecpOpTx.SignSECP256K1Fx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}}))
 
 	txID, err := vm.IssueTx(mintSecpOpTx.Bytes())
 	require.NoError(err)
@@ -1103,11 +1068,10 @@ func TestServiceGetTxJSON_OperationTxWithSecpMintOp(t *testing.T) {
 
 	reply := api.GetTxReply{}
 	s := &Service{vm: vm}
-	err = s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID:     txID,
 		Encoding: formatting.JSON,
-	}, &reply)
-	require.NoError(err)
+	}, &reply))
 
 	require.Equal(reply.Encoding, formatting.JSON)
 	jsonTxBytes, err := stdjson.Marshal(reply.Tx)
@@ -1142,7 +1106,7 @@ func TestServiceGetTxJSON_OperationTxWithMultipleSecpMintOp(t *testing.T) {
 
 	genesisBytes := BuildGenesisTest(t)
 	issuer := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		baseDBManager,
@@ -1165,8 +1129,7 @@ func TestServiceGetTxJSON_OperationTxWithMultipleSecpMintOp(t *testing.T) {
 			},
 		},
 		&common.SenderTest{T: t},
-	)
-	require.NoError(err)
+	))
 	vm.batchTimeout = 0
 
 	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
@@ -1174,15 +1137,14 @@ func TestServiceGetTxJSON_OperationTxWithMultipleSecpMintOp(t *testing.T) {
 
 	key := keys[0]
 	createAssetTx := newAvaxCreateAssetTxWithOutputs(t, vm)
-	_, err = vm.IssueTx(createAssetTx.Bytes())
+	_, err := vm.IssueTx(createAssetTx.Bytes())
 	require.NoError(err)
 
 	op1 := buildSecpMintOp(createAssetTx, key, 0)
 	op2 := buildSecpMintOp(createAssetTx, key, 1)
 	mintSecpOpTx := buildOperationTxWithOp(op1, op2)
 
-	err = mintSecpOpTx.SignSECP256K1Fx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}, {key}})
-	require.NoError(err)
+	require.NoError(mintSecpOpTx.SignSECP256K1Fx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}, {key}}))
 
 	txID, err := vm.IssueTx(mintSecpOpTx.Bytes())
 	require.NoError(err)
@@ -1200,11 +1162,10 @@ func TestServiceGetTxJSON_OperationTxWithMultipleSecpMintOp(t *testing.T) {
 
 	reply := api.GetTxReply{}
 	s := &Service{vm: vm}
-	err = s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID:     txID,
 		Encoding: formatting.JSON,
-	}, &reply)
-	require.NoError(err)
+	}, &reply))
 
 	require.Equal(reply.Encoding, formatting.JSON)
 	jsonTxBytes, err := stdjson.Marshal(reply.Tx)
@@ -1237,7 +1198,7 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOp(t *testing.T) {
 
 	genesisBytes := BuildGenesisTest(t)
 	issuer := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		baseDBManager,
@@ -1260,8 +1221,7 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOp(t *testing.T) {
 			},
 		},
 		&common.SenderTest{T: t},
-	)
-	require.NoError(err)
+	))
 	vm.batchTimeout = 0
 
 	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
@@ -1269,12 +1229,11 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOp(t *testing.T) {
 
 	key := keys[0]
 	createAssetTx := newAvaxCreateAssetTxWithOutputs(t, vm)
-	_, err = vm.IssueTx(createAssetTx.Bytes())
+	_, err := vm.IssueTx(createAssetTx.Bytes())
 	require.NoError(err)
 
 	mintPropertyFxOpTx := buildOperationTxWithOp(buildPropertyFxMintOp(createAssetTx, key, 4))
-	err = mintPropertyFxOpTx.SignPropertyFx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}})
-	require.NoError(err)
+	require.NoError(mintPropertyFxOpTx.SignPropertyFx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}}))
 
 	txID, err := vm.IssueTx(mintPropertyFxOpTx.Bytes())
 	require.NoError(err)
@@ -1292,11 +1251,10 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOp(t *testing.T) {
 
 	reply := api.GetTxReply{}
 	s := &Service{vm: vm}
-	err = s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID:     txID,
 		Encoding: formatting.JSON,
-	}, &reply)
-	require.NoError(err)
+	}, &reply))
 
 	require.Equal(reply.Encoding, formatting.JSON)
 	jsonTxBytes, err := stdjson.Marshal(reply.Tx)
@@ -1330,7 +1288,7 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOpMultiple(t *testing.T)
 
 	genesisBytes := BuildGenesisTest(t)
 	issuer := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		baseDBManager,
@@ -1353,8 +1311,7 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOpMultiple(t *testing.T)
 			},
 		},
 		&common.SenderTest{T: t},
-	)
-	require.NoError(err)
+	))
 	vm.batchTimeout = 0
 
 	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
@@ -1362,15 +1319,14 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOpMultiple(t *testing.T)
 
 	key := keys[0]
 	createAssetTx := newAvaxCreateAssetTxWithOutputs(t, vm)
-	_, err = vm.IssueTx(createAssetTx.Bytes())
+	_, err := vm.IssueTx(createAssetTx.Bytes())
 	require.NoError(err)
 
 	op1 := buildPropertyFxMintOp(createAssetTx, key, 4)
 	op2 := buildPropertyFxMintOp(createAssetTx, key, 5)
 	mintPropertyFxOpTx := buildOperationTxWithOp(op1, op2)
 
-	err = mintPropertyFxOpTx.SignPropertyFx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}, {key}})
-	require.NoError(err)
+	require.NoError(mintPropertyFxOpTx.SignPropertyFx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}, {key}}))
 
 	txID, err := vm.IssueTx(mintPropertyFxOpTx.Bytes())
 	require.NoError(err)
@@ -1388,11 +1344,10 @@ func TestServiceGetTxJSON_OperationTxWithPropertyFxMintOpMultiple(t *testing.T)
 
 	reply := api.GetTxReply{}
 	s := &Service{vm: vm}
-	err = s.GetTx(nil, &api.GetTxArgs{
+	require.NoError(s.GetTx(nil, &api.GetTxArgs{
 		TxID:     txID,
 		Encoding: formatting.JSON,
-	}, &reply)
-	require.NoError(err)
+	}, &reply))
 
 	require.Equal(reply.Encoding, formatting.JSON)
 	jsonTxBytes, err := stdjson.Marshal(reply.Tx)
diff --git a/vms/avm/states/state_test.go b/vms/avm/states/state_test.go
index 35533a84bb34..149ad0927f6c 100644
--- a/vms/avm/states/state_test.go
+++ b/vms/avm/states/state_test.go
@@ -281,8 +281,7 @@ func TestInitializeChainState(t *testing.T) {
 
 	stopVertexID := ids.GenerateTestID()
 	genesisTimestamp := version.CortinaDefaultTime
-	err = s.InitializeChainState(stopVertexID, genesisTimestamp)
-	require.NoError(err)
+	require.NoError(s.InitializeChainState(stopVertexID, genesisTimestamp))
 
 	lastAcceptedID := s.GetLastAccepted()
 	genesis, err := s.GetBlock(lastAcceptedID)
@@ -301,11 +300,9 @@ func TestInitializeChainState(t *testing.T) {
 
 	s.AddBlock(childBlock)
 	s.SetLastAccepted(childBlock.ID())
-	err = s.Commit()
-	require.NoError(err)
+	require.NoError(s.Commit())
 
-	err = s.InitializeChainState(stopVertexID, genesisTimestamp)
-	require.NoError(err)
+	require.NoError(s.InitializeChainState(stopVertexID, genesisTimestamp))
 
 	lastAcceptedID = s.GetLastAccepted()
 	lastAccepted, err := s.GetBlock(lastAcceptedID)
diff --git a/vms/avm/txs/base_tx_test.go b/vms/avm/txs/base_tx_test.go
index 0259c3eb525b..f61f35ee60eb 100644
--- a/vms/avm/txs/base_tx_test.go
+++ b/vms/avm/txs/base_tx_test.go
@@ -186,14 +186,13 @@ func TestBaseTxSerialization(t *testing.T) {
 		0xc8, 0x06, 0xd7, 0x43, 0x00,
 	}
 
-	err = tx.SignSECP256K1Fx(
+	require.NoError(tx.SignSECP256K1Fx(
 		parser.Codec(),
 		[][]*secp256k1.PrivateKey{
 			{keys[0], keys[0]},
 			{keys[0], keys[0]},
 		},
-	)
-	require.NoError(err)
+	))
 	require.Equal(tx.ID().String(), "QnTUuie2qe6BKyYrC2jqd73bJ828QNhYnZbdA2HWsnVRPjBfV")
 
 	// there are two credentials
diff --git a/vms/avm/txs/executor/semantic_verifier_test.go b/vms/avm/txs/executor/semantic_verifier_test.go
index b5157fb97b2f..1eb3d2e35015 100644
--- a/vms/avm/txs/executor/semantic_verifier_test.go
+++ b/vms/avm/txs/executor/semantic_verifier_test.go
@@ -131,13 +131,12 @@ func TestSemanticVerifierBaseTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &baseTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: nil,
@@ -158,13 +157,12 @@ func TestSemanticVerifierBaseTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &baseTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: errAssetIDMismatch,
@@ -190,13 +188,12 @@ func TestSemanticVerifierBaseTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &baseTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: errIncompatibleFx,
@@ -215,13 +212,12 @@ func TestSemanticVerifierBaseTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &baseTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[1]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: secp256k1fx.ErrWrongSig,
@@ -239,13 +235,12 @@ func TestSemanticVerifierBaseTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &baseTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: database.ErrNotFound,
@@ -270,13 +265,12 @@ func TestSemanticVerifierBaseTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &baseTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: secp256k1fx.ErrMismatchedAmounts,
@@ -309,11 +303,10 @@ func TestSemanticVerifierBaseTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &baseTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: errIncompatibleFx,
@@ -332,13 +325,12 @@ func TestSemanticVerifierBaseTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &baseTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: database.ErrNotFound,
@@ -361,13 +353,12 @@ func TestSemanticVerifierBaseTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &baseTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: errNotAnAsset,
@@ -509,13 +500,12 @@ func TestSemanticVerifierExportTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &exportTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: nil,
@@ -536,13 +526,12 @@ func TestSemanticVerifierExportTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &exportTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: errAssetIDMismatch,
@@ -568,13 +557,12 @@ func TestSemanticVerifierExportTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &exportTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: errIncompatibleFx,
@@ -593,13 +581,12 @@ func TestSemanticVerifierExportTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &exportTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[1]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: secp256k1fx.ErrWrongSig,
@@ -617,13 +604,12 @@ func TestSemanticVerifierExportTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &exportTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: database.ErrNotFound,
@@ -648,13 +634,12 @@ func TestSemanticVerifierExportTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &exportTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: secp256k1fx.ErrMismatchedAmounts,
@@ -687,11 +672,10 @@ func TestSemanticVerifierExportTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &exportTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: errIncompatibleFx,
@@ -710,13 +694,12 @@ func TestSemanticVerifierExportTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &exportTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: database.ErrNotFound,
@@ -739,13 +722,12 @@ func TestSemanticVerifierExportTx(t *testing.T) {
 				tx := &txs.Tx{
 					Unsigned: &exportTx,
 				}
-				err := tx.SignSECP256K1Fx(
+				require.NoError(tx.SignSECP256K1Fx(
 					codec,
 					[][]*secp256k1.PrivateKey{
 						{keys[0]},
 					},
-				)
-				require.NoError(err)
+				))
 				return tx
 			},
 			err: errNotAnAsset,
@@ -877,13 +859,12 @@ func TestSemanticVerifierExportTxDifferentSubnet(t *testing.T) {
 	tx := &txs.Tx{
 		Unsigned: &exportTx,
 	}
-	err = tx.SignSECP256K1Fx(
+	require.NoError(tx.SignSECP256K1Fx(
 		codec,
 		[][]*secp256k1.PrivateKey{
 			{keys[0]},
 		},
-	)
-	require.NoError(err)
+	))
 
 	err = tx.Unsigned.Visit(&SemanticVerifier{
 		Backend: backend,
diff --git a/vms/avm/txs/export_tx_test.go b/vms/avm/txs/export_tx_test.go
index c02504e9e071..a7c1ed16196f 100644
--- a/vms/avm/txs/export_tx_test.go
+++ b/vms/avm/txs/export_tx_test.go
@@ -168,14 +168,13 @@ func TestExportTxSerialization(t *testing.T) {
 		0x8f, 0xe0, 0x2a, 0xf3, 0xcc, 0x31, 0x32, 0xef, 0xfe, 0x7d,
 		0x3d, 0x9f, 0x14, 0x94, 0x01,
 	}
-	err = tx.SignSECP256K1Fx(
+	require.NoError(tx.SignSECP256K1Fx(
 		parser.Codec(),
 		[][]*secp256k1.PrivateKey{
 			{keys[0], keys[0]},
 			{keys[0], keys[0]},
 		},
-	)
-	require.NoError(err)
+	))
 	require.Equal(tx.ID().String(), "2oG52e7Cb7XF1yUzv3pRFndAypgbpswWRcSAKD5SH5VgaiTm5D")
 
 	// there are two credentials
diff --git a/vms/avm/txs/import_tx_test.go b/vms/avm/txs/import_tx_test.go
index 47c1eb01201c..4172a4047792 100644
--- a/vms/avm/txs/import_tx_test.go
+++ b/vms/avm/txs/import_tx_test.go
@@ -168,14 +168,13 @@ func TestImportTxSerialization(t *testing.T) {
 		0x1f, 0x49, 0x9b, 0x0a, 0x4f, 0xbf, 0x95, 0xfc, 0x31, 0x39,
 		0x46, 0x4e, 0xa1, 0xaf, 0x00,
 	}
-	err = tx.SignSECP256K1Fx(
+	require.NoError(tx.SignSECP256K1Fx(
 		parser.Codec(),
 		[][]*secp256k1.PrivateKey{
 			{keys[0], keys[0]},
 			{keys[0], keys[0]},
 		},
-	)
-	require.NoError(err)
+	))
 	require.Equal(tx.ID().String(), "pCW7sVBytzdZ1WrqzGY1DvA2S9UaMr72xpUMxVyx1QHBARNYx")
 
 	// there are two credentials
diff --git a/vms/avm/txs/mempool/mempool_test.go b/vms/avm/txs/mempool/mempool_test.go
index 0f633b75e877..5e69304fe4ad 100644
--- a/vms/avm/txs/mempool/mempool_test.go
+++ b/vms/avm/txs/mempool/mempool_test.go
@@ -50,8 +50,7 @@ func TestBlockBuilderMaxMempoolSizeHandling(t *testing.T) {
 	// shortcut to simulated almost filled mempool
 	mempool.bytesAvailable = len(tx.Bytes())
 
-	err = mempool.Add(tx)
-	require.NoError(err)
+	require.NoError(mempool.Add(tx))
 }
 
 func TestTxsInMempool(t *testing.T) {
diff --git a/vms/avm/vm_regression_test.go b/vms/avm/vm_regression_test.go
index de148c05754b..1e9f0f6dd67f 100644
--- a/vms/avm/vm_regression_test.go
+++ b/vms/avm/vm_regression_test.go
@@ -35,7 +35,7 @@ func TestVerifyFxUsage(t *testing.T) {
 
 	genesisBytes := BuildGenesisTest(t)
 	issuer := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		manager.NewMemDB(version.Semantic1_0_0),
@@ -54,8 +54,7 @@ func TestVerifyFxUsage(t *testing.T) {
 			},
 		},
 		nil,
-	)
-	require.NoError(err)
+	))
 	vm.batchTimeout = 0
 
 	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
@@ -98,7 +97,7 @@ func TestVerifyFxUsage(t *testing.T) {
 	}}
 	require.NoError(vm.parser.InitializeTx(createAssetTx))
 
-	_, err = vm.IssueTx(createAssetTx.Bytes())
+	_, err := vm.IssueTx(createAssetTx.Bytes())
 	require.NoError(err)
 
 	mintNFTTx := &txs.Tx{Unsigned: &txs.OperationTx{
diff --git a/vms/avm/vm_test.go b/vms/avm/vm_test.go
index f8ee1c4fc332..177bb1e7b7ec 100644
--- a/vms/avm/vm_test.go
+++ b/vms/avm/vm_test.go
@@ -773,19 +773,18 @@ func TestIssueNFT(t *testing.T) {
 
 // Test issuing a transaction that creates an Property family
 func TestIssueProperty(t *testing.T) {
+	require := require.New(t)
 	vm := &VM{}
 	ctx := NewContext(t)
 	ctx.Lock.Lock()
 	defer func() {
-		if err := vm.Shutdown(context.Background()); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(vm.Shutdown(context.Background()))
 		ctx.Lock.Unlock()
 	}()
 
 	genesisBytes := BuildGenesisTest(t)
 	issuer := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		manager.NewMemDB(version.Semantic1_0_0),
@@ -808,21 +807,11 @@ func TestIssueProperty(t *testing.T) {
 			},
 		},
 		nil,
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
+	))
 	vm.batchTimeout = 0
 
-	err = vm.SetState(context.Background(), snow.Bootstrapping)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = vm.SetState(context.Background(), snow.NormalOp)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
+	require.NoError(vm.SetState(context.Background(), snow.NormalOp))
 
 	createAssetTx := &txs.Tx{Unsigned: &txs.CreateAssetTx{
 		BaseTx: txs.BaseTx{BaseTx: avax.BaseTx{
@@ -844,13 +833,10 @@ func TestIssueProperty(t *testing.T) {
 			},
 		}},
 	}}
-	if err := vm.parser.InitializeTx(createAssetTx); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(vm.parser.InitializeTx(createAssetTx))
 
-	if _, err := vm.IssueTx(createAssetTx.Bytes()); err != nil {
-		t.Fatal(err)
-	}
+	_, err := vm.IssueTx(createAssetTx.Bytes())
+	require.NoError(err)
 
 	mintPropertyTx := &txs.Tx{Unsigned: &txs.OperationTx{
 		BaseTx: txs.BaseTx{BaseTx: avax.BaseTx{
@@ -879,16 +865,12 @@ func TestIssueProperty(t *testing.T) {
 	}}
 
 	codec := vm.parser.Codec()
-	err = mintPropertyTx.SignPropertyFx(codec, [][]*secp256k1.PrivateKey{
+	require.NoError(mintPropertyTx.SignPropertyFx(codec, [][]*secp256k1.PrivateKey{
 		{keys[0]},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
+	}))
 
-	if _, err := vm.IssueTx(mintPropertyTx.Bytes()); err != nil {
-		t.Fatal(err)
-	}
+	_, err = vm.IssueTx(mintPropertyTx.Bytes())
+	require.NoError(err)
 
 	burnPropertyTx := &txs.Tx{Unsigned: &txs.OperationTx{
 		BaseTx: txs.BaseTx{BaseTx: avax.BaseTx{
@@ -905,16 +887,12 @@ func TestIssueProperty(t *testing.T) {
 		}},
 	}}
 
-	err = burnPropertyTx.SignPropertyFx(codec, [][]*secp256k1.PrivateKey{
+	require.NoError(burnPropertyTx.SignPropertyFx(codec, [][]*secp256k1.PrivateKey{
 		{},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
+	}))
 
-	if _, err := vm.IssueTx(burnPropertyTx.Bytes()); err != nil {
-		t.Fatal(err)
-	}
+	_, err = vm.IssueTx(burnPropertyTx.Bytes())
+	require.NoError(err)
 }
 
 func setupTxFeeAssets(t *testing.T) ([]byte, chan common.Message, *VM, *atomic.Memory) {
@@ -978,8 +956,7 @@ func TestIssueTxWithFeeAsset(t *testing.T) {
 	genesisBytes, issuer, vm, _ := setupTxFeeAssets(t)
 	ctx := vm.ctx
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, vm.Shutdown(context.Background()))
 		ctx.Lock.Unlock()
 	}()
 	// send first asset
@@ -1004,8 +981,7 @@ func TestIssueTxWithAnotherAsset(t *testing.T) {
 	genesisBytes, issuer, vm, _ := setupTxFeeAssets(t)
 	ctx := vm.ctx
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, vm.Shutdown(context.Background()))
 		ctx.Lock.Unlock()
 	}()
 
@@ -1763,6 +1739,7 @@ func TestImportTxNotState(t *testing.T) {
 
 // Test issuing an import transaction.
 func TestIssueExportTx(t *testing.T) {
+	require := require.New(t)
 	genesisBytes := BuildGenesisTest(t)
 
 	issuer := make(chan common.Message, 1)
@@ -1779,7 +1756,7 @@ func TestIssueExportTx(t *testing.T) {
 
 	ctx.Lock.Lock()
 	vm := &VM{}
-	if err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		baseDBManager.NewPrefixDBManager([]byte{1}),
@@ -1791,18 +1768,11 @@ func TestIssueExportTx(t *testing.T) {
 			Fx: &secp256k1fx.Fx{},
 		}},
 		nil,
-	); err != nil {
-		t.Fatal(err)
-	}
+	))
 	vm.batchTimeout = 0
 
-	if err := vm.SetState(context.Background(), snow.Bootstrapping); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := vm.SetState(context.Background(), snow.NormalOp); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
+	require.NoError(vm.SetState(context.Background(), snow.NormalOp))
 
 	key := keys[0]
 
@@ -1834,40 +1804,27 @@ func TestIssueExportTx(t *testing.T) {
 			},
 		}},
 	}}
-	if err := tx.SignSECP256K1Fx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}}); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(tx.SignSECP256K1Fx(vm.parser.Codec(), [][]*secp256k1.PrivateKey{{key}}))
 
-	if _, err := vm.IssueTx(tx.Bytes()); err != nil {
-		t.Fatal(err)
-	}
+	_, err := vm.IssueTx(tx.Bytes())
+	require.NoError(err)
 
 	ctx.Lock.Unlock()
 
-	msg := <-issuer
-	if msg != common.PendingTxs {
-		t.Fatalf("Wrong message")
-	}
+	require.Equal(common.PendingTxs, <-issuer)
 
 	ctx.Lock.Lock()
 	defer func() {
-		if err := vm.Shutdown(context.Background()); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(vm.Shutdown(context.Background()))
 		ctx.Lock.Unlock()
 	}()
 
 	txs := vm.PendingTxs(context.Background())
-	if len(txs) != 1 {
-		t.Fatalf("Should have returned %d tx(s)", 1)
-	}
+	require.Len(txs, 1)
 
 	parsedTx := txs[0]
-	if err := parsedTx.Verify(context.Background()); err != nil {
-		t.Fatal(err)
-	} else if err := parsedTx.Accept(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(parsedTx.Verify(context.Background()))
+	require.NoError(parsedTx.Accept(context.Background()))
 
 	peerSharedMemory := m.NewSharedMemory(constants.PlatformChainID)
 	utxoBytes, _, _, err := peerSharedMemory.Indexed(
@@ -1879,12 +1836,8 @@ func TestIssueExportTx(t *testing.T) {
 		nil,
 		math.MaxInt32,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(utxoBytes) != 1 {
-		t.Fatalf("wrong number of utxos %d", len(utxoBytes))
-	}
+	require.NoError(err)
+	require.Len(utxoBytes, 1)
 }
 
 func TestClearForceAcceptedExportTx(t *testing.T) {
diff --git a/vms/components/avax/utxo_fetching_test.go b/vms/components/avax/utxo_fetching_test.go
index 0b8f4f71f8ca..e483508ef66f 100644
--- a/vms/components/avax/utxo_fetching_test.go
+++ b/vms/components/avax/utxo_fetching_test.go
@@ -54,8 +54,7 @@ func TestFetchUTXOs(t *testing.T) {
 	db := memdb.New()
 	s := NewUTXOState(db, manager)
 
-	err := s.PutUTXO(utxo)
-	require.NoError(err)
+	require.NoError(s.PutUTXO(utxo))
 
 	utxos, err := GetAllUTXOs(s, addrs)
 	require.NoError(err)
@@ -111,8 +110,7 @@ func TestGetPaginatedUTXOs(t *testing.T) {
 				},
 			},
 		}
-		err := s.PutUTXO(utxo0)
-		require.NoError(err)
+		require.NoError(s.PutUTXO(utxo0))
 
 		utxo1 := &UTXO{
 			UTXOID: UTXOID{
@@ -129,8 +127,7 @@ func TestGetPaginatedUTXOs(t *testing.T) {
 				},
 			},
 		}
-		err = s.PutUTXO(utxo1)
-		require.NoError(err)
+		require.NoError(s.PutUTXO(utxo1))
 
 		utxo2 := &UTXO{
 			UTXOID: UTXOID{
@@ -147,8 +144,7 @@ func TestGetPaginatedUTXOs(t *testing.T) {
 				},
 			},
 		}
-		err = s.PutUTXO(utxo2)
-		require.NoError(err)
+		require.NoError(s.PutUTXO(utxo2))
 	}
 
 	var (
diff --git a/vms/components/avax/utxo_state_test.go b/vms/components/avax/utxo_state_test.go
index 993fab7606fd..864d31f3565c 100644
--- a/vms/components/avax/utxo_state_test.go
+++ b/vms/components/avax/utxo_state_test.go
@@ -63,11 +63,9 @@ func TestUTXOState(t *testing.T) {
 	_, err = s.GetUTXO(utxoID)
 	require.Equal(database.ErrNotFound, err)
 
-	err = s.DeleteUTXO(utxoID)
-	require.NoError(err)
+	require.NoError(s.DeleteUTXO(utxoID))
 
-	err = s.PutUTXO(utxo)
-	require.NoError(err)
+	require.NoError(s.PutUTXO(utxo))
 
 	utxoIDs, err := s.UTXOIDs(addr[:], ids.Empty, 5)
 	require.NoError(err)
@@ -77,14 +75,12 @@ func TestUTXOState(t *testing.T) {
 	require.NoError(err)
 	require.Equal(utxo, readUTXO)
 
-	err = s.DeleteUTXO(utxoID)
-	require.NoError(err)
+	require.NoError(s.DeleteUTXO(utxoID))
 
 	_, err = s.GetUTXO(utxoID)
 	require.Equal(database.ErrNotFound, err)
 
-	err = s.PutUTXO(utxo)
-	require.NoError(err)
+	require.NoError(s.PutUTXO(utxo))
 
 	s = NewUTXOState(db, manager)
 
diff --git a/vms/components/chain/state_test.go b/vms/components/chain/state_test.go
index 9fdad9d8f84a..28b83f1f8225 100644
--- a/vms/components/chain/state_test.go
+++ b/vms/components/chain/state_test.go
@@ -920,15 +920,13 @@ func TestIsProcessing(t *testing.T) {
 	require.False(t, chainState.IsProcessing(parsedBlk1.ID()))
 
 	// Verify blk1
-	err = parsedBlk1.Verify(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, parsedBlk1.Verify(context.Background()))
 
 	// Check that it is processing in consensus
 	require.True(t, chainState.IsProcessing(parsedBlk1.ID()))
 
 	// Accept blk1
-	err = parsedBlk1.Accept(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, parsedBlk1.Accept(context.Background()))
 
 	// Check that it is no longer processing in consensus
 	require.False(t, chainState.IsProcessing(parsedBlk1.ID()))
diff --git a/vms/components/keystore/user_test.go b/vms/components/keystore/user_test.go
index 379897e9d2a8..a06c13a340a1 100644
--- a/vms/components/keystore/user_test.go
+++ b/vms/components/keystore/user_test.go
@@ -24,8 +24,7 @@ func TestUserClosedDB(t *testing.T) {
 	db, err := encdb.New([]byte(testPassword), memdb.New())
 	require.NoError(err)
 
-	err = db.Close()
-	require.NoError(err)
+	require.NoError(db.Close())
 
 	u := NewUserFromDB(db)
 
@@ -62,12 +61,10 @@ func TestUser(t *testing.T) {
 	sk, err := factory.NewPrivateKey()
 	require.NoError(err)
 
-	err = u.PutKeys(sk)
-	require.NoError(err)
+	require.NoError(u.PutKeys(sk))
 
 	// Putting the same key multiple times should be a noop
-	err = u.PutKeys(sk)
-	require.NoError(err)
+	require.NoError(u.PutKeys(sk))
 
 	addr := sk.PublicKey().Address()
 
diff --git a/vms/components/message/handler_test.go b/vms/components/message/handler_test.go
index cd6c5173eaaf..489c973b68e0 100644
--- a/vms/components/message/handler_test.go
+++ b/vms/components/message/handler_test.go
@@ -27,8 +27,7 @@ func TestHandleTx(t *testing.T) {
 	handler := CounterHandler{}
 	msg := Tx{}
 
-	err := msg.Handle(&handler, ids.EmptyNodeID, 0)
-	require.NoError(err)
+	require.NoError(msg.Handle(&handler, ids.EmptyNodeID, 0))
 	require.Equal(1, handler.Tx)
 }
 
@@ -37,6 +36,5 @@ func TestNoopHandler(t *testing.T) {
 		Log: logging.NoLog{},
 	}
 
-	err := handler.HandleTx(ids.EmptyNodeID, 0, nil)
-	require.NoError(t, err)
+	require.NoError(t, handler.HandleTx(ids.EmptyNodeID, 0, nil))
 }
diff --git a/vms/platformvm/blocks/builder/builder_test.go b/vms/platformvm/blocks/builder/builder_test.go
index 3f3efe80affa..eea7e1612935 100644
--- a/vms/platformvm/blocks/builder/builder_test.go
+++ b/vms/platformvm/blocks/builder/builder_test.go
@@ -51,8 +51,7 @@ func TestBlockBuilderAddLocalTx(t *testing.T) {
 	env.sender.SendAppGossipF = func(context.Context, []byte) error {
 		return nil
 	}
-	err := env.Builder.AddUnverifiedTx(tx)
-	require.NoError(err)
+	require.NoError(env.Builder.AddUnverifiedTx(tx))
 
 	has := env.mempool.Has(txID)
 	require.True(has)
diff --git a/vms/platformvm/blocks/builder/network_test.go b/vms/platformvm/blocks/builder/network_test.go
index 51777fdd8240..365fc130553a 100644
--- a/vms/platformvm/blocks/builder/network_test.go
+++ b/vms/platformvm/blocks/builder/network_test.go
@@ -60,8 +60,7 @@ func TestMempoolValidGossipedTxIsAddedToMempool(t *testing.T) {
 	// Free lock because [AppGossip] waits for the context lock
 	env.ctx.Lock.Unlock()
 	// show that unknown tx is added to mempool
-	err = env.AppGossip(context.Background(), nodeID, msgBytes)
-	require.NoError(err)
+	require.NoError(env.AppGossip(context.Background(), nodeID, msgBytes))
 	require.True(env.Builder.Has(txID))
 	// Grab lock back
 	env.ctx.Lock.Lock()
@@ -101,9 +100,8 @@ func TestMempoolInvalidGossipedTxIsNotAddedToMempool(t *testing.T) {
 	msgBytes, err := message.Build(&msg)
 	require.NoError(err)
 	env.ctx.Lock.Unlock()
-	err = env.AppGossip(context.Background(), nodeID, msgBytes)
+	require.NoError(env.AppGossip(context.Background(), nodeID, msgBytes))
 	env.ctx.Lock.Lock()
-	require.NoError(err)
 	require.False(env.Builder.Has(txID))
 }
 
@@ -127,8 +125,7 @@ func TestMempoolNewLocaTxIsGossiped(t *testing.T) {
 	tx := getValidTx(env.txBuilder, t)
 	txID := tx.ID()
 
-	err := env.Builder.AddUnverifiedTx(tx)
-	require.NoError(err)
+	require.NoError(env.Builder.AddUnverifiedTx(tx))
 	require.NotNil(gossipedBytes)
 
 	// show gossiped bytes can be decoded to the original tx
@@ -144,8 +141,7 @@ func TestMempoolNewLocaTxIsGossiped(t *testing.T) {
 	// show that transaction is not re-gossiped is recently added to mempool
 	gossipedBytes = nil
 	env.Builder.Remove([]*txs.Tx{tx})
-	err = env.Builder.Add(tx)
-	require.NoError(err)
+	require.NoError(env.Builder.Add(tx))
 
 	require.Nil(gossipedBytes)
 }
diff --git a/vms/platformvm/blocks/builder/standard_block_test.go b/vms/platformvm/blocks/builder/standard_block_test.go
index 8fa9c71682c7..827d7357728b 100644
--- a/vms/platformvm/blocks/builder/standard_block_test.go
+++ b/vms/platformvm/blocks/builder/standard_block_test.go
@@ -54,7 +54,7 @@ func TestAtomicTxImports(t *testing.T) {
 	require.NoError(err)
 
 	inputID := utxo.InputID()
-	err = peerSharedMemory.Apply(map[ids.ID]*atomic.Requests{
+	require.NoError(peerSharedMemory.Apply(map[ids.ID]*atomic.Requests{
 		env.ctx.ChainID: {PutRequests: []*atomic.Element{{
 			Key:   inputID[:],
 			Value: utxoBytes,
@@ -62,8 +62,7 @@ func TestAtomicTxImports(t *testing.T) {
 				recipientKey.PublicKey().Address().Bytes(),
 			},
 		}}},
-	})
-	require.NoError(err)
+	}))
 
 	tx, err := env.txBuilder.NewImportTx(
 		env.ctx.XChainID,
diff --git a/vms/platformvm/blocks/executor/acceptor_test.go b/vms/platformvm/blocks/executor/acceptor_test.go
index 6a3de730ec5f..933d2d9e4b97 100644
--- a/vms/platformvm/blocks/executor/acceptor_test.go
+++ b/vms/platformvm/blocks/executor/acceptor_test.go
@@ -64,8 +64,7 @@ func TestAcceptorVisitProposalBlock(t *testing.T) {
 		validators: validators.TestManager,
 	}
 
-	err = acceptor.ApricotProposalBlock(blk)
-	require.NoError(err)
+	require.NoError(acceptor.ApricotProposalBlock(blk))
 
 	require.Equal(blkID, acceptor.backend.lastAccepted)
 
@@ -154,8 +153,7 @@ func TestAcceptorVisitAtomicBlock(t *testing.T) {
 	onAcceptState.EXPECT().Apply(s).Times(1)
 	sharedMemory.EXPECT().Apply(atomicRequests, batch).Return(nil).Times(1)
 
-	err = acceptor.ApricotAtomicBlock(blk)
-	require.NoError(err)
+	require.NoError(acceptor.ApricotAtomicBlock(blk))
 }
 
 func TestAcceptorVisitStandardBlock(t *testing.T) {
@@ -244,8 +242,7 @@ func TestAcceptorVisitStandardBlock(t *testing.T) {
 	onAcceptState.EXPECT().Apply(s).Times(1)
 	sharedMemory.EXPECT().Apply(atomicRequests, batch).Return(nil).Times(1)
 
-	err = acceptor.BanffStandardBlock(blk)
-	require.NoError(err)
+	require.NoError(acceptor.BanffStandardBlock(blk))
 	require.True(calledOnAcceptFunc)
 	require.Equal(blk.ID(), acceptor.backend.lastAccepted)
 }
@@ -337,8 +334,7 @@ func TestAcceptorVisitCommitBlock(t *testing.T) {
 		s.EXPECT().Commit().Return(nil).Times(1),
 	)
 
-	err = acceptor.ApricotCommitBlock(blk)
-	require.NoError(err)
+	require.NoError(acceptor.ApricotCommitBlock(blk))
 	require.Equal(blk.ID(), acceptor.backend.lastAccepted)
 }
 
@@ -430,7 +426,6 @@ func TestAcceptorVisitAbortBlock(t *testing.T) {
 		s.EXPECT().Commit().Return(nil).Times(1),
 	)
 
-	err = acceptor.ApricotAbortBlock(blk)
-	require.NoError(err)
+	require.NoError(acceptor.ApricotAbortBlock(blk))
 	require.Equal(blk.ID(), acceptor.backend.lastAccepted)
 }
diff --git a/vms/platformvm/blocks/executor/rejector_test.go b/vms/platformvm/blocks/executor/rejector_test.go
index 3c909e6bddf4..538fdf7775ca 100644
--- a/vms/platformvm/blocks/executor/rejector_test.go
+++ b/vms/platformvm/blocks/executor/rejector_test.go
@@ -147,8 +147,7 @@ func TestRejectBlock(t *testing.T) {
 				state.EXPECT().Commit().Return(nil).Times(1),
 			)
 
-			err = tt.rejectFunc(rejector, blk)
-			require.NoError(err)
+			require.NoError(tt.rejectFunc(rejector, blk))
 			// Make sure block and its parent are removed from the state map.
 			require.NotContains(rejector.blkIDToState, blk.ID())
 		})
diff --git a/vms/platformvm/blocks/executor/verifier_test.go b/vms/platformvm/blocks/executor/verifier_test.go
index 098fb9eee8c7..fd12dec60214 100644
--- a/vms/platformvm/blocks/executor/verifier_test.go
+++ b/vms/platformvm/blocks/executor/verifier_test.go
@@ -98,8 +98,7 @@ func TestVerifierVisitProposalBlock(t *testing.T) {
 
 	// Visit the block
 	blk := manager.NewBlock(apricotBlk)
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 	require.Contains(verifier.backend.blkIDToState, apricotBlk.ID())
 	gotBlkState := verifier.backend.blkIDToState[apricotBlk.ID()]
 	require.Equal(apricotBlk, gotBlkState.statelessBlock)
@@ -115,8 +114,7 @@ func TestVerifierVisitProposalBlock(t *testing.T) {
 	require.Equal(status.Aborted, gotStatus)
 
 	// Visiting again should return nil without using dependencies.
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 }
 
 func TestVerifierVisitAtomicBlock(t *testing.T) {
@@ -195,8 +193,7 @@ func TestVerifierVisitAtomicBlock(t *testing.T) {
 	onAccept.EXPECT().GetTimestamp().Return(timestamp).Times(1)
 
 	blk := manager.NewBlock(apricotBlk)
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 
 	require.Contains(verifier.backend.blkIDToState, apricotBlk.ID())
 	gotBlkState := verifier.backend.blkIDToState[apricotBlk.ID()]
@@ -206,8 +203,7 @@ func TestVerifierVisitAtomicBlock(t *testing.T) {
 	require.Equal(timestamp, gotBlkState.timestamp)
 
 	// Visiting again should return nil without using dependencies.
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 }
 
 func TestVerifierVisitStandardBlock(t *testing.T) {
@@ -297,8 +293,7 @@ func TestVerifierVisitStandardBlock(t *testing.T) {
 	mempool.EXPECT().Remove(apricotBlk.Txs()).Times(1)
 
 	blk := manager.NewBlock(apricotBlk)
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 
 	// Assert expected state.
 	require.Contains(verifier.backend.blkIDToState, apricotBlk.ID())
@@ -308,8 +303,7 @@ func TestVerifierVisitStandardBlock(t *testing.T) {
 	require.Equal(timestamp, gotBlkState.timestamp)
 
 	// Visiting again should return nil without using dependencies.
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 }
 
 func TestVerifierVisitCommitBlock(t *testing.T) {
@@ -371,8 +365,7 @@ func TestVerifierVisitCommitBlock(t *testing.T) {
 
 	// Verify the block.
 	blk := manager.NewBlock(apricotBlk)
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 
 	// Assert expected state.
 	require.Contains(verifier.backend.blkIDToState, apricotBlk.ID())
@@ -381,8 +374,7 @@ func TestVerifierVisitCommitBlock(t *testing.T) {
 	require.Equal(timestamp, gotBlkState.timestamp)
 
 	// Visiting again should return nil without using dependencies.
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 }
 
 func TestVerifierVisitAbortBlock(t *testing.T) {
@@ -444,8 +436,7 @@ func TestVerifierVisitAbortBlock(t *testing.T) {
 
 	// Verify the block.
 	blk := manager.NewBlock(apricotBlk)
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 
 	// Assert expected state.
 	require.Contains(verifier.backend.blkIDToState, apricotBlk.ID())
@@ -454,8 +445,7 @@ func TestVerifierVisitAbortBlock(t *testing.T) {
 	require.Equal(timestamp, gotBlkState.timestamp)
 
 	// Visiting again should return nil without using dependencies.
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 }
 
 // Assert that a block with an unverified parent fails verification.
diff --git a/vms/platformvm/health_test.go b/vms/platformvm/health_test.go
index 7a7d67b4bc3b..40ef4142cccc 100644
--- a/vms/platformvm/health_test.go
+++ b/vms/platformvm/health_test.go
@@ -29,8 +29,7 @@ func TestHealthCheckPrimaryNetwork(t *testing.T) {
 	}()
 	genesisState, _ := defaultGenesis()
 	for index, validator := range genesisState.Validators {
-		err := vm.Connected(context.Background(), validator.NodeID, version.CurrentApp)
-		require.NoError(err)
+		require.NoError(vm.Connected(context.Background(), validator.NodeID, version.CurrentApp))
 		details, err := vm.HealthCheck(context.Background())
 		if float64((index+1)*20) >= defaultMinConnectedStake*100 {
 			require.NoError(err)
@@ -72,8 +71,7 @@ func TestHealthCheckSubnet(t *testing.T) {
 			testVdrCount := 4
 			for i := 0; i < testVdrCount; i++ {
 				subnetVal := ids.GenerateTestNodeID()
-				err := subnetVdrs.Add(subnetVal, nil, ids.Empty, 100)
-				require.NoError(err)
+				require.NoError(subnetVdrs.Add(subnetVal, nil, ids.Empty, 100))
 			}
 			ok := vm.Validators.Add(subnetID, subnetVdrs)
 			require.True(ok)
@@ -81,8 +79,7 @@ func TestHealthCheckSubnet(t *testing.T) {
 			// connect to all primary network validators first
 			genesisState, _ := defaultGenesis()
 			for _, validator := range genesisState.Validators {
-				err := vm.Connected(context.Background(), validator.NodeID, version.CurrentApp)
-				require.NoError(err)
+				require.NoError(vm.Connected(context.Background(), validator.NodeID, version.CurrentApp))
 			}
 			var expectedMinStake float64
 			if test.useDefault {
@@ -94,8 +91,7 @@ func TestHealthCheckSubnet(t *testing.T) {
 				}
 			}
 			for index, vdr := range subnetVdrs.List() {
-				err := vm.ConnectedSubnet(context.Background(), vdr.NodeID, subnetID)
-				require.NoError(err)
+				require.NoError(vm.ConnectedSubnet(context.Background(), vdr.NodeID, subnetID))
 				details, err := vm.HealthCheck(context.Background())
 				connectedPerc := float64((index + 1) * (100 / testVdrCount))
 				if connectedPerc >= expectedMinStake*100 {
diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go
index 944855f58ca0..05c5798bd590 100644
--- a/vms/platformvm/service_test.go
+++ b/vms/platformvm/service_test.go
@@ -72,8 +72,7 @@ func defaultService(t *testing.T) (*Service, *mutableSharedMemory) {
 	vm.ctx.Lock.Lock()
 	defer vm.ctx.Lock.Unlock()
 	ks := keystore.New(logging.NoLog{}, manager.NewMemDB(version.Semantic1_0_0))
-	err := ks.CreateUser(testUsername, testPassword)
-	require.NoError(t, err)
+	require.NoError(t, ks.CreateUser(testUsername, testPassword))
 
 	vm.ctx.Keystore = ks.NewBlockchainKeyStore(vm.ctx.ChainID)
 	return &Service{
@@ -95,8 +94,7 @@ func defaultAddress(t *testing.T, service *Service) {
 	pk, err := testKeyFactory.ToPrivateKey(testPrivateKey)
 	require.NoError(t, err)
 
-	err = user.PutKeys(pk, keys[0])
-	require.NoError(t, err)
+	require.NoError(t, user.PutKeys(pk, keys[0]))
 }
 
 func TestAddValidator(t *testing.T) {
@@ -110,10 +108,9 @@ func TestAddValidator(t *testing.T) {
 func TestCreateBlockchainArgsParsing(t *testing.T) {
 	jsonString := `{"vmID":"lol","fxIDs":["secp256k1"], "name":"awesome", "username":"bob loblaw", "password":"yeet", "genesisData":"SkB92YpWm4Q2iPnLGCuDPZPgUQMxajqQQuz91oi3xD984f8r"}`
 	args := CreateBlockchainArgs{}
-	err := stdjson.Unmarshal([]byte(jsonString), &args)
-	require.NoError(t, err)
+	require.NoError(t, stdjson.Unmarshal([]byte(jsonString), &args))
 
-	_, err = stdjson.Marshal(args.GenesisData)
+	_, err := stdjson.Marshal(args.GenesisData)
 	require.NoError(t, err)
 }
 
@@ -121,21 +118,18 @@ func TestExportKey(t *testing.T) {
 	require := require.New(t)
 	jsonString := `{"username":"ScoobyUser","password":"ShaggyPassword1Zoinks!","address":"` + testAddress + `"}`
 	args := ExportKeyArgs{}
-	err := stdjson.Unmarshal([]byte(jsonString), &args)
-	require.NoError(err)
+	require.NoError(stdjson.Unmarshal([]byte(jsonString), &args))
 
 	service, _ := defaultService(t)
 	defaultAddress(t, service)
 	service.vm.ctx.Lock.Lock()
 	defer func() {
-		err := service.vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(service.vm.Shutdown(context.Background()))
 		service.vm.ctx.Lock.Unlock()
 	}()
 
 	reply := ExportKeyReply{}
-	err = service.ExportKey(nil, &args, &reply)
-	require.NoError(err)
+	require.NoError(service.ExportKey(nil, &args, &reply))
 
 	require.Equal(testPrivateKey, reply.PrivateKey.Bytes())
 }
@@ -144,20 +138,17 @@ func TestImportKey(t *testing.T) {
 	require := require.New(t)
 	jsonString := `{"username":"ScoobyUser","password":"ShaggyPassword1Zoinks!","privateKey":"PrivateKey-ewoqjP7PxY4yr3iLTpLisriqt94hdyDFNgchSxGGztUrTXtNN"}`
 	args := ImportKeyArgs{}
-	err := stdjson.Unmarshal([]byte(jsonString), &args)
-	require.NoError(err)
+	require.NoError(stdjson.Unmarshal([]byte(jsonString), &args))
 
 	service, _ := defaultService(t)
 	service.vm.ctx.Lock.Lock()
 	defer func() {
-		err := service.vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(service.vm.Shutdown(context.Background()))
 		service.vm.ctx.Lock.Unlock()
 	}()
 
 	reply := api.JSONAddress{}
-	err = service.ImportKey(nil, &args, &reply)
-	require.NoError(err)
+	require.NoError(service.ImportKey(nil, &args, &reply))
 	require.Equal(testAddress, reply.Address)
 }
 
@@ -168,8 +159,7 @@ func TestGetTxStatus(t *testing.T) {
 	defaultAddress(t, service)
 	service.vm.ctx.Lock.Lock()
 	defer func() {
-		err := service.vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(service.vm.Shutdown(context.Background()))
 		service.vm.ctx.Lock.Unlock()
 	}()
 
@@ -202,7 +192,7 @@ func TestGetTxStatus(t *testing.T) {
 	require.NoError(err)
 
 	inputID := utxo.InputID()
-	err = peerSharedMemory.Apply(map[ids.ID]*atomic.Requests{
+	require.NoError(peerSharedMemory.Apply(map[ids.ID]*atomic.Requests{
 		service.vm.ctx.ChainID: {
 			PutRequests: []*atomic.Element{
 				{
@@ -214,8 +204,7 @@ func TestGetTxStatus(t *testing.T) {
 				},
 			},
 		},
-	})
-	require.NoError(err)
+	}))
 
 	oldSharedMemory := mutableSharedMemory.SharedMemory
 	mutableSharedMemory.SharedMemory = sm
@@ -229,8 +218,7 @@ func TestGetTxStatus(t *testing.T) {
 		arg  = &GetTxStatusArgs{TxID: tx.ID()}
 		resp GetTxStatusResponse
 	)
-	err = service.GetTxStatus(nil, arg, &resp)
-	require.NoError(err)
+	require.NoError(service.GetTxStatus(nil, arg, &resp))
 	require.Equal(status.Unknown, resp.Status)
 	require.Zero(resp.Reason)
 
@@ -240,22 +228,18 @@ func TestGetTxStatus(t *testing.T) {
 
 	mutableSharedMemory.SharedMemory = sm
 
-	err = service.vm.Builder.AddUnverifiedTx(tx)
-	require.NoError(err)
+	require.NoError(service.vm.Builder.AddUnverifiedTx(tx))
 
 	block, err := service.vm.BuildBlock(context.Background())
 	require.NoError(err)
 
 	blk := block.(*blockexecutor.Block)
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 
-	err = blk.Accept(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Accept(context.Background()))
 
 	resp = GetTxStatusResponse{} // reset
-	err = service.GetTxStatus(nil, arg, &resp)
-	require.NoError(err)
+	require.NoError(service.GetTxStatus(nil, arg, &resp))
 	require.Equal(status.Committed, resp.Status)
 	require.Zero(resp.Reason)
 }
@@ -334,17 +318,14 @@ func TestGetTx(t *testing.T) {
 				err = service.GetTx(nil, arg, &response)
 				require.ErrorIs(err, database.ErrNotFound) // We haven't issued the tx yet
 
-				err = service.vm.Builder.AddUnverifiedTx(tx)
-				require.NoError(err)
+				require.NoError(service.vm.Builder.AddUnverifiedTx(tx))
 
 				block, err := service.vm.BuildBlock(context.Background())
 				require.NoError(err)
 
-				err = block.Verify(context.Background())
-				require.NoError(err)
+				require.NoError(block.Verify(context.Background()))
 
-				err = block.Accept(context.Background())
-				require.NoError(err)
+				require.NoError(block.Accept(context.Background()))
 
 				if blk, ok := block.(snowman.OracleBlock); ok { // For proposal blocks, commit them
 					options, err := blk.Options(context.Background())
@@ -354,16 +335,13 @@ func TestGetTx(t *testing.T) {
 						commit := options[0].(*blockexecutor.Block)
 						require.IsType(&blocks.BanffCommitBlock{}, commit.Block)
 
-						err := commit.Verify(context.Background())
-						require.NoError(err)
+						require.NoError(commit.Verify(context.Background()))
 
-						err = commit.Accept(context.Background())
-						require.NoError(err)
+						require.NoError(commit.Accept(context.Background()))
 					}
 				}
 
-				err = service.GetTx(nil, arg, &response)
-				require.NoError(err)
+				require.NoError(service.GetTx(nil, arg, &response))
 
 				switch encoding {
 				case formatting.Hex:
@@ -378,8 +356,7 @@ func TestGetTx(t *testing.T) {
 					require.Equal(tx.ID(), responseTx.ID())
 				}
 
-				err = service.vm.Shutdown(context.Background())
-				require.NoError(err)
+				require.NoError(service.vm.Shutdown(context.Background()))
 				service.vm.ctx.Lock.Unlock()
 			})
 		}
@@ -393,8 +370,7 @@ func TestGetBalance(t *testing.T) {
 	defaultAddress(t, service)
 	service.vm.ctx.Lock.Lock()
 	defer func() {
-		err := service.vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(service.vm.Shutdown(context.Background()))
 		service.vm.ctx.Lock.Unlock()
 	}()
 
@@ -589,8 +565,7 @@ func TestGetCurrentValidators(t *testing.T) {
 	defaultAddress(t, service)
 	service.vm.ctx.Lock.Lock()
 	defer func() {
-		err := service.vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(service.vm.Shutdown(context.Background()))
 		service.vm.ctx.Lock.Unlock()
 	}()
 
@@ -600,8 +575,7 @@ func TestGetCurrentValidators(t *testing.T) {
 	args := GetCurrentValidatorsArgs{SubnetID: constants.PrimaryNetworkID}
 	response := GetCurrentValidatorsReply{}
 
-	err := service.GetCurrentValidators(nil, &args, &response)
-	require.NoError(err)
+	require.NoError(service.GetCurrentValidators(nil, &args, &response))
 	require.Len(response.Validators, len(genesis.Validators))
 
 	for _, vdr := range genesis.Validators {
@@ -645,13 +619,11 @@ func TestGetCurrentValidators(t *testing.T) {
 
 	service.vm.state.PutCurrentDelegator(staker)
 	service.vm.state.AddTx(delTx, status.Committed)
-	err = service.vm.state.Commit()
-	require.NoError(err)
+	require.NoError(service.vm.state.Commit())
 
 	// Call getCurrentValidators
 	args = GetCurrentValidatorsArgs{SubnetID: constants.PrimaryNetworkID}
-	err = service.GetCurrentValidators(nil, &args, &response)
-	require.NoError(err)
+	require.NoError(service.GetCurrentValidators(nil, &args, &response))
 	require.Len(response.Validators, len(genesis.Validators))
 
 	// Make sure the delegator is there
@@ -670,8 +642,7 @@ func TestGetCurrentValidators(t *testing.T) {
 			NodeIDs:  []ids.NodeID{vdr.NodeID},
 		}
 		innerResponse := GetCurrentValidatorsReply{}
-		err = service.GetCurrentValidators(nil, &innerArgs, &innerResponse)
-		require.NoError(err)
+		require.NoError(service.GetCurrentValidators(nil, &innerArgs, &innerResponse))
 		require.Len(innerResponse.Validators, 1)
 
 		innerVdr := innerResponse.Validators[0].(pchainapi.PermissionlessValidator)
@@ -786,8 +757,7 @@ func TestGetBlock(t *testing.T) {
 				Encoding: test.encoding,
 			}
 			response := api.GetBlockResponse{}
-			err = service.GetBlock(nil, &args, &response)
-			require.NoError(err)
+			require.NoError(service.GetBlock(nil, &args, &response))
 
 			switch {
 			case test.encoding == formatting.JSON:
diff --git a/vms/platformvm/state/validator_metadata_test.go b/vms/platformvm/state/validator_metadata_test.go
index 09d4a6818703..15fa19649528 100644
--- a/vms/platformvm/state/validator_metadata_test.go
+++ b/vms/platformvm/state/validator_metadata_test.go
@@ -46,8 +46,7 @@ func TestValidatorUptimes(t *testing.T) {
 	// set uptime
 	newUpDuration := testMetadata.UpDuration + 1
 	newLastUpdated := testMetadata.lastUpdated.Add(time.Hour)
-	err = state.SetUptime(nodeID, subnetID, newUpDuration, newLastUpdated)
-	require.NoError(err)
+	require.NoError(state.SetUptime(nodeID, subnetID, newUpDuration, newLastUpdated))
 
 	// get new uptime
 	upDuration, lastUpdated, err = state.GetUptime(nodeID, subnetID)
@@ -83,8 +82,7 @@ func TestWriteValidatorMetadata(t *testing.T) {
 	primaryDB := memdb.New()
 	subnetDB := memdb.New()
 	// write empty uptimes
-	err := state.WriteValidatorMetadata(primaryDB, subnetDB)
-	require.NoError(err)
+	require.NoError(state.WriteValidatorMetadata(primaryDB, subnetDB))
 
 	// load uptime
 	nodeID := ids.GenerateTestNodeID()
@@ -98,8 +96,7 @@ func TestWriteValidatorMetadata(t *testing.T) {
 	state.LoadValidatorMetadata(nodeID, subnetID, testUptimeReward)
 
 	// write state, should not reflect to DB yet
-	err = state.WriteValidatorMetadata(primaryDB, subnetDB)
-	require.NoError(err)
+	require.NoError(state.WriteValidatorMetadata(primaryDB, subnetDB))
 	require.False(primaryDB.Has(testUptimeReward.txID[:]))
 	require.False(subnetDB.Has(testUptimeReward.txID[:]))
 
@@ -112,12 +109,10 @@ func TestWriteValidatorMetadata(t *testing.T) {
 	// update uptimes
 	newUpDuration := testUptimeReward.UpDuration + 1
 	newLastUpdated := testUptimeReward.lastUpdated.Add(time.Hour)
-	err = state.SetUptime(nodeID, subnetID, newUpDuration, newLastUpdated)
-	require.NoError(err)
+	require.NoError(state.SetUptime(nodeID, subnetID, newUpDuration, newLastUpdated))
 
 	// write uptimes, should reflect to subnet DB
-	err = state.WriteValidatorMetadata(primaryDB, subnetDB)
-	require.NoError(err)
+	require.NoError(state.WriteValidatorMetadata(primaryDB, subnetDB))
 	require.False(primaryDB.Has(testUptimeReward.txID[:]))
 	require.True(subnetDB.Has(testUptimeReward.txID[:]))
 }
@@ -149,8 +144,7 @@ func TestValidatorDelegateeRewards(t *testing.T) {
 
 	// set delegatee reward
 	newDelegateeReward := testMetadata.PotentialDelegateeReward + 100000
-	err = state.SetDelegateeReward(subnetID, nodeID, newDelegateeReward)
-	require.NoError(err)
+	require.NoError(state.SetDelegateeReward(subnetID, nodeID, newDelegateeReward))
 
 	// get new delegatee reward
 	delegateeReward, err = state.GetDelegateeReward(subnetID, nodeID)
diff --git a/vms/platformvm/status/blockchain_status_test.go b/vms/platformvm/status/blockchain_status_test.go
index 08216ad77f6b..97b96badcb93 100644
--- a/vms/platformvm/status/blockchain_status_test.go
+++ b/vms/platformvm/status/blockchain_status_test.go
@@ -26,8 +26,7 @@ func TestBlockchainStatusJSON(t *testing.T) {
 		require.NoError(err)
 
 		var parsedStatus BlockchainStatus
-		err = json.Unmarshal(statusJSON, &parsedStatus)
-		require.NoError(err)
+		require.NoError(json.Unmarshal(statusJSON, &parsedStatus))
 		require.Equal(status, parsedStatus)
 	}
 
@@ -39,8 +38,7 @@ func TestBlockchainStatusJSON(t *testing.T) {
 
 	{
 		status := Validating
-		err := json.Unmarshal([]byte("null"), &status)
-		require.NoError(err)
+		require.NoError(json.Unmarshal([]byte("null"), &status))
 		require.Equal(Validating, status)
 	}
 
diff --git a/vms/platformvm/status/status_test.go b/vms/platformvm/status/status_test.go
index 78670a01fe44..59316f983722 100644
--- a/vms/platformvm/status/status_test.go
+++ b/vms/platformvm/status/status_test.go
@@ -26,8 +26,7 @@ func TestStatusJSON(t *testing.T) {
 		require.NoError(err)
 
 		var parsedStatus Status
-		err = json.Unmarshal(statusJSON, &parsedStatus)
-		require.NoError(err)
+		require.NoError(json.Unmarshal(statusJSON, &parsedStatus))
 		require.Equal(status, parsedStatus)
 	}
 
@@ -39,8 +38,7 @@ func TestStatusJSON(t *testing.T) {
 
 	{
 		status := Committed
-		err := json.Unmarshal([]byte("null"), &status)
-		require.NoError(err)
+		require.NoError(json.Unmarshal([]byte("null"), &status))
 		require.Equal(Committed, status)
 	}
 
diff --git a/vms/platformvm/txs/executor/advance_time_test.go b/vms/platformvm/txs/executor/advance_time_test.go
index 1a8a26accd54..4e658a623dca 100644
--- a/vms/platformvm/txs/executor/advance_time_test.go
+++ b/vms/platformvm/txs/executor/advance_time_test.go
@@ -141,8 +141,7 @@ func TestAdvanceTimeTxTimestampTooLate(t *testing.T) {
 		require.ErrorIs(err, ErrChildBlockAfterStakerChangeTime)
 	}
 
-	err = shutdownEnvironment(env)
-	require.NoError(err)
+	require.NoError(shutdownEnvironment(env))
 
 	// Case: Timestamp is after next validator end time
 	env = newEnvironment(false /*=postBanff*/, false /*=postCortina*/)
@@ -589,8 +588,7 @@ func TestTrackedSubnet(t *testing.T) {
 			env.state.PutPendingValidator(staker)
 			env.state.AddTx(tx, status.Committed)
 			env.state.SetHeight(dummyHeight)
-			err = env.state.Commit()
-			require.NoError(err)
+			require.NoError(env.state.Commit())
 
 			// Advance time to the staker's start time.
 			env.clk.Set(subnetVdr1StartTime)
@@ -609,8 +607,7 @@ func TestTrackedSubnet(t *testing.T) {
 				Backend:       &env.backend,
 				Tx:            tx,
 			}
-			err = tx.Unsigned.Visit(&executor)
-			require.NoError(err)
+			require.NoError(tx.Unsigned.Visit(&executor))
 
 			require.NoError(executor.OnCommitState.Apply(env.state))
 
@@ -659,8 +656,7 @@ func TestAdvanceTimeTxDelegatorStakerWeight(t *testing.T) {
 		Backend:       &env.backend,
 		Tx:            tx,
 	}
-	err = tx.Unsigned.Visit(&executor)
-	require.NoError(err)
+	require.NoError(tx.Unsigned.Visit(&executor))
 
 	require.NoError(executor.OnCommitState.Apply(env.state))
 
@@ -719,8 +715,7 @@ func TestAdvanceTimeTxDelegatorStakerWeight(t *testing.T) {
 		Backend:       &env.backend,
 		Tx:            tx,
 	}
-	err = tx.Unsigned.Visit(&executor)
-	require.NoError(err)
+	require.NoError(tx.Unsigned.Visit(&executor))
 
 	require.NoError(executor.OnCommitState.Apply(env.state))
 
@@ -764,8 +759,7 @@ func TestAdvanceTimeTxDelegatorStakers(t *testing.T) {
 		Backend:       &env.backend,
 		Tx:            tx,
 	}
-	err = tx.Unsigned.Visit(&executor)
-	require.NoError(err)
+	require.NoError(tx.Unsigned.Visit(&executor))
 
 	require.NoError(executor.OnCommitState.Apply(env.state))
 
@@ -819,8 +813,7 @@ func TestAdvanceTimeTxDelegatorStakers(t *testing.T) {
 		Backend:       &env.backend,
 		Tx:            tx,
 	}
-	err = tx.Unsigned.Visit(&executor)
-	require.NoError(err)
+	require.NoError(tx.Unsigned.Visit(&executor))
 
 	require.NoError(executor.OnCommitState.Apply(env.state))
 
@@ -858,8 +851,7 @@ func TestAdvanceTimeTxInitiallyPrefersCommit(t *testing.T) {
 		Backend:       &env.backend,
 		Tx:            tx,
 	}
-	err = tx.Unsigned.Visit(&executor)
-	require.NoError(err)
+	require.NoError(tx.Unsigned.Visit(&executor))
 
 	require.True(executor.PrefersCommit, "should prefer to commit this tx because its proposed timestamp it's within sync bound")
 }
diff --git a/vms/platformvm/txs/executor/create_chain_test.go b/vms/platformvm/txs/executor/create_chain_test.go
index 4ca3ae84270d..97ccb8d6013b 100644
--- a/vms/platformvm/txs/executor/create_chain_test.go
+++ b/vms/platformvm/txs/executor/create_chain_test.go
@@ -161,8 +161,7 @@ func TestCreateChainTxValid(t *testing.T) {
 		State:   stateDiff,
 		Tx:      tx,
 	}
-	err = tx.Unsigned.Visit(&executor)
-	require.NoError(err)
+	require.NoError(tx.Unsigned.Visit(&executor))
 }
 
 func TestCreateChainTxAP3FeeChange(t *testing.T) {
@@ -224,8 +223,7 @@ func TestCreateChainTxAP3FeeChange(t *testing.T) {
 				SubnetAuth: subnetAuth,
 			}
 			tx := &txs.Tx{Unsigned: utx}
-			err = tx.Sign(txs.Codec, signers)
-			require.NoError(err)
+			require.NoError(tx.Sign(txs.Codec, signers))
 
 			stateDiff, err := state.NewDiff(lastAcceptedID, env)
 			require.NoError(err)
diff --git a/vms/platformvm/txs/executor/export_test.go b/vms/platformvm/txs/executor/export_test.go
index 547f933c3079..15f8b87fc371 100644
--- a/vms/platformvm/txs/executor/export_test.go
+++ b/vms/platformvm/txs/executor/export_test.go
@@ -77,8 +77,7 @@ func TestNewExportTx(t *testing.T) {
 				StateVersions: env,
 				Tx:            tx,
 			}
-			err = tx.Unsigned.Visit(&verifier)
-			require.NoError(err)
+			require.NoError(tx.Unsigned.Visit(&verifier))
 		})
 	}
 }
diff --git a/vms/platformvm/txs/executor/import_test.go b/vms/platformvm/txs/executor/import_test.go
index 7a17dbd7b04b..c4aac439c10d 100644
--- a/vms/platformvm/txs/executor/import_test.go
+++ b/vms/platformvm/txs/executor/import_test.go
@@ -72,7 +72,7 @@ func TestNewImportTx(t *testing.T) {
 			require.NoError(t, err)
 
 			inputID := utxo.InputID()
-			err = peerSharedMemory.Apply(map[ids.ID]*atomic.Requests{
+			require.NoError(t, peerSharedMemory.Apply(map[ids.ID]*atomic.Requests{
 				env.ctx.ChainID: {
 					PutRequests: []*atomic.Element{
 						{
@@ -84,9 +84,7 @@ func TestNewImportTx(t *testing.T) {
 						},
 					},
 				},
-			},
-			)
-			require.NoError(t, err)
+			}))
 		}
 
 		return sm
@@ -199,8 +197,7 @@ func TestNewImportTx(t *testing.T) {
 				StateVersions: env,
 				Tx:            tx,
 			}
-			err = tx.Unsigned.Visit(&verifier)
-			require.NoError(err)
+			require.NoError(tx.Unsigned.Visit(&verifier))
 		})
 	}
 }
diff --git a/vms/platformvm/txs/executor/proposal_tx_executor_test.go b/vms/platformvm/txs/executor/proposal_tx_executor_test.go
index 458aceb1776d..f9f1fc333fc2 100644
--- a/vms/platformvm/txs/executor/proposal_tx_executor_test.go
+++ b/vms/platformvm/txs/executor/proposal_tx_executor_test.go
@@ -56,8 +56,7 @@ func TestProposalTxExecuteAddDelegator(t *testing.T) {
 		target.state.PutCurrentValidator(staker)
 		target.state.AddTx(tx, status.Committed)
 		target.state.SetHeight(dummyHeight)
-		err = target.state.Commit()
-		require.NoError(t, err)
+		require.NoError(t, target.state.Commit())
 	}
 
 	// [addMaxStakeValidator] adds a new validator to the primary network's
@@ -85,8 +84,7 @@ func TestProposalTxExecuteAddDelegator(t *testing.T) {
 		target.state.PutCurrentValidator(staker)
 		target.state.AddTx(tx, status.Committed)
 		target.state.SetHeight(dummyHeight)
-		err = target.state.Commit()
-		require.NoError(t, err)
+		require.NoError(t, target.state.Commit())
 	}
 
 	dummyH := newEnvironment(false /*=postBanff*/, false /*=postCortina*/)
@@ -209,8 +207,7 @@ func TestProposalTxExecuteAddDelegator(t *testing.T) {
 					target.state.DeleteUTXO(utxoID)
 				}
 				target.state.SetHeight(dummyHeight)
-				err = target.state.Commit()
-				require.NoError(t, err)
+				require.NoError(t, target.state.Commit())
 			},
 			AP3Time:     defaultGenesisTime,
 			expectedErr: ErrFlowCheckFailed,
@@ -352,8 +349,7 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) {
 			Backend:       &env.backend,
 			Tx:            tx,
 		}
-		err = tx.Unsigned.Visit(&executor)
-		require.NoError(err)
+		require.NoError(tx.Unsigned.Visit(&executor))
 	}
 
 	// Add a validator to pending validator set of primary network
@@ -417,8 +413,7 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) {
 	env.state.AddTx(addDSTx, status.Committed)
 	dummyHeight := uint64(1)
 	env.state.SetHeight(dummyHeight)
-	err = env.state.Commit()
-	require.NoError(err)
+	require.NoError(env.state.Commit())
 
 	// Node with ID key.PublicKey().Address() now a pending validator for primary network
 
@@ -508,8 +503,7 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) {
 			Backend:       &env.backend,
 			Tx:            tx,
 		}
-		err = tx.Unsigned.Visit(&executor)
-		require.NoError(err)
+		require.NoError(tx.Unsigned.Visit(&executor))
 	}
 
 	// Case: Proposed validator start validating at/before current timestamp
@@ -571,8 +565,7 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) {
 	env.state.PutCurrentValidator(staker)
 	env.state.AddTx(subnetTx, status.Committed)
 	env.state.SetHeight(dummyHeight)
-	err = env.state.Commit()
-	require.NoError(err)
+	require.NoError(env.state.Commit())
 
 	{
 		// Node with ID nodeIDKey.PublicKey().Address() now validating subnet with ID testSubnet1.ID
@@ -605,8 +598,7 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) {
 
 	env.state.DeleteCurrentValidator(staker)
 	env.state.SetHeight(dummyHeight)
-	err = env.state.Commit()
-	require.NoError(err)
+	require.NoError(env.state.Commit())
 
 	{
 		// Case: Too few signatures
@@ -702,8 +694,7 @@ func TestProposalTxExecuteAddSubnetValidator(t *testing.T) {
 		env.state.PutCurrentValidator(staker)
 		env.state.AddTx(tx, status.Committed)
 		env.state.SetHeight(dummyHeight)
-		err = env.state.Commit()
-		require.NoError(err)
+		require.NoError(env.state.Commit())
 
 		onCommitState, err := state.NewDiff(lastAcceptedID, env)
 		require.NoError(err)
@@ -847,8 +838,7 @@ func TestProposalTxExecuteAddValidator(t *testing.T) {
 		env.state.AddTx(tx, status.Committed)
 		dummyHeight := uint64(1)
 		env.state.SetHeight(dummyHeight)
-		err = env.state.Commit()
-		require.NoError(err)
+		require.NoError(env.state.Commit())
 
 		onCommitState, err := state.NewDiff(lastAcceptedID, env)
 		require.NoError(err)
diff --git a/vms/platformvm/txs/executor/reward_validator_test.go b/vms/platformvm/txs/executor/reward_validator_test.go
index 9434a4ab1474..3e1ce2162ff8 100644
--- a/vms/platformvm/txs/executor/reward_validator_test.go
+++ b/vms/platformvm/txs/executor/reward_validator_test.go
@@ -308,8 +308,7 @@ func TestRewardDelegatorTxExecuteOnCommitPreDelegateeDeferral(t *testing.T) {
 		Backend:       &env.backend,
 		Tx:            tx,
 	}
-	err = tx.Unsigned.Visit(&txExecutor)
-	require.NoError(err)
+	require.NoError(tx.Unsigned.Visit(&txExecutor))
 
 	vdrDestSet := set.Set[ids.ShortID]{}
 	vdrDestSet.Add(vdrRewardAddress)
@@ -446,8 +445,7 @@ func TestRewardDelegatorTxExecuteOnCommitPostDelegateeDeferral(t *testing.T) {
 		Backend:       &env.backend,
 		Tx:            tx,
 	}
-	err = tx.Unsigned.Visit(&txExecutor)
-	require.NoError(err)
+	require.NoError(tx.Unsigned.Visit(&txExecutor))
 
 	// The delegator should be rewarded if the ProposalTx is committed. Since the
 	// delegatee's share is 25%, we expect the delegator to receive 75% of the reward.
@@ -809,8 +807,7 @@ func TestRewardDelegatorTxExecuteOnAbort(t *testing.T) {
 		Backend:       &env.backend,
 		Tx:            tx,
 	}
-	err = tx.Unsigned.Visit(&txExecutor)
-	require.NoError(err)
+	require.NoError(tx.Unsigned.Visit(&txExecutor))
 
 	vdrDestSet := set.Set[ids.ShortID]{}
 	vdrDestSet.Add(vdrRewardAddress)
diff --git a/vms/platformvm/txs/executor/standard_tx_executor_test.go b/vms/platformvm/txs/executor/standard_tx_executor_test.go
index c88358d7c8ee..4cfb1dbce129 100644
--- a/vms/platformvm/txs/executor/standard_tx_executor_test.go
+++ b/vms/platformvm/txs/executor/standard_tx_executor_test.go
@@ -130,8 +130,7 @@ func TestStandardTxExecutorAddDelegator(t *testing.T) {
 		target.state.PutCurrentValidator(staker)
 		target.state.AddTx(tx, status.Committed)
 		target.state.SetHeight(dummyHeight)
-		err = target.state.Commit()
-		require.NoError(t, err)
+		require.NoError(t, target.state.Commit())
 	}
 
 	// [addMaxStakeValidator] adds a new validator to the primary network's
@@ -159,8 +158,7 @@ func TestStandardTxExecutorAddDelegator(t *testing.T) {
 		target.state.PutCurrentValidator(staker)
 		target.state.AddTx(tx, status.Committed)
 		target.state.SetHeight(dummyHeight)
-		err = target.state.Commit()
-		require.NoError(t, err)
+		require.NoError(t, target.state.Commit())
 	}
 
 	dummyH := newEnvironment(false /*=postBanff*/, false /*=postCortina*/)
@@ -291,8 +289,7 @@ func TestStandardTxExecutorAddDelegator(t *testing.T) {
 					target.state.DeleteUTXO(utxoID)
 				}
 				target.state.SetHeight(dummyHeight)
-				err = target.state.Commit()
-				require.NoError(t, err)
+				require.NoError(t, target.state.Commit())
 			},
 			AP3Time:              defaultGenesisTime,
 			expectedExecutionErr: ErrFlowCheckFailed,
@@ -438,8 +435,7 @@ func TestStandardTxExecutorAddSubnetValidator(t *testing.T) {
 			State:   onAcceptState,
 			Tx:      tx,
 		}
-		err = tx.Unsigned.Visit(&executor)
-		require.NoError(err)
+		require.NoError(tx.Unsigned.Visit(&executor))
 	}
 
 	// Add a validator to pending validator set of primary network
@@ -500,8 +496,7 @@ func TestStandardTxExecutorAddSubnetValidator(t *testing.T) {
 	env.state.AddTx(addDSTx, status.Committed)
 	dummyHeight := uint64(1)
 	env.state.SetHeight(dummyHeight)
-	err = env.state.Commit()
-	require.NoError(err)
+	require.NoError(env.state.Commit())
 
 	// Node with ID key.PublicKey().Address() now a pending validator for primary network
 
@@ -578,8 +573,7 @@ func TestStandardTxExecutorAddSubnetValidator(t *testing.T) {
 			State:   onAcceptState,
 			Tx:      tx,
 		}
-		err = tx.Unsigned.Visit(&executor)
-		require.NoError(err)
+		require.NoError(tx.Unsigned.Visit(&executor))
 	}
 
 	// Case: Proposed validator start validating at/before current timestamp
@@ -637,8 +631,7 @@ func TestStandardTxExecutorAddSubnetValidator(t *testing.T) {
 	env.state.PutCurrentValidator(staker)
 	env.state.AddTx(subnetTx, status.Committed)
 	env.state.SetHeight(dummyHeight)
-	err = env.state.Commit()
-	require.NoError(err)
+	require.NoError(env.state.Commit())
 
 	{
 		// Node with ID nodeIDKey.PublicKey().Address() now validating subnet with ID testSubnet1.ID
@@ -668,8 +661,7 @@ func TestStandardTxExecutorAddSubnetValidator(t *testing.T) {
 
 	env.state.DeleteCurrentValidator(staker)
 	env.state.SetHeight(dummyHeight)
-	err = env.state.Commit()
-	require.NoError(err)
+	require.NoError(env.state.Commit())
 
 	{
 		// Case: Duplicate signatures
@@ -793,8 +785,7 @@ func TestStandardTxExecutorAddSubnetValidator(t *testing.T) {
 		env.state.PutCurrentValidator(staker)
 		env.state.AddTx(tx, status.Committed)
 		env.state.SetHeight(dummyHeight)
-		err = env.state.Commit()
-		require.NoError(err)
+		require.NoError(env.state.Commit())
 
 		onAcceptState, err := state.NewDiff(lastAcceptedID, env)
 		require.NoError(err)
diff --git a/vms/platformvm/txs/txheap/by_end_time_test.go b/vms/platformvm/txs/txheap/by_end_time_test.go
index 05995683de92..33ddc3cc3d1a 100644
--- a/vms/platformvm/txs/txheap/by_end_time_test.go
+++ b/vms/platformvm/txs/txheap/by_end_time_test.go
@@ -30,8 +30,7 @@ func TestByStopTime(t *testing.T) {
 		RewardsOwner: &secp256k1fx.OutputOwners{},
 	}
 	tx0 := &txs.Tx{Unsigned: utx0}
-	err := tx0.Initialize(txs.Codec)
-	require.NoError(err)
+	require.NoError(tx0.Initialize(txs.Codec))
 
 	utx1 := &txs.AddValidatorTx{
 		Validator: txs.Validator{
@@ -42,8 +41,7 @@ func TestByStopTime(t *testing.T) {
 		RewardsOwner: &secp256k1fx.OutputOwners{},
 	}
 	tx1 := &txs.Tx{Unsigned: utx1}
-	err = tx1.Initialize(txs.Codec)
-	require.NoError(err)
+	require.NoError(tx1.Initialize(txs.Codec))
 
 	utx2 := &txs.AddValidatorTx{
 		Validator: txs.Validator{
@@ -54,8 +52,7 @@ func TestByStopTime(t *testing.T) {
 		RewardsOwner: &secp256k1fx.OutputOwners{},
 	}
 	tx2 := &txs.Tx{Unsigned: utx2}
-	err = tx2.Initialize(txs.Codec)
-	require.NoError(err)
+	require.NoError(tx2.Initialize(txs.Codec))
 
 	txHeap.Add(tx2)
 	require.Equal(utx2.EndTime(), txHeap.Timestamp())
diff --git a/vms/platformvm/txs/txheap/by_start_time_test.go b/vms/platformvm/txs/txheap/by_start_time_test.go
index fe9180d0c154..164e2ec35e59 100644
--- a/vms/platformvm/txs/txheap/by_start_time_test.go
+++ b/vms/platformvm/txs/txheap/by_start_time_test.go
@@ -30,8 +30,7 @@ func TestByStartTime(t *testing.T) {
 		RewardsOwner: &secp256k1fx.OutputOwners{},
 	}
 	tx0 := &txs.Tx{Unsigned: utx0}
-	err := tx0.Initialize(txs.Codec)
-	require.NoError(err)
+	require.NoError(tx0.Initialize(txs.Codec))
 
 	utx1 := &txs.AddValidatorTx{
 		Validator: txs.Validator{
@@ -42,8 +41,7 @@ func TestByStartTime(t *testing.T) {
 		RewardsOwner: &secp256k1fx.OutputOwners{},
 	}
 	tx1 := &txs.Tx{Unsigned: utx1}
-	err = tx1.Initialize(txs.Codec)
-	require.NoError(err)
+	require.NoError(tx1.Initialize(txs.Codec))
 
 	utx2 := &txs.AddValidatorTx{
 		Validator: txs.Validator{
@@ -54,8 +52,7 @@ func TestByStartTime(t *testing.T) {
 		RewardsOwner: &secp256k1fx.OutputOwners{},
 	}
 	tx2 := &txs.Tx{Unsigned: utx2}
-	err = tx2.Initialize(txs.Codec)
-	require.NoError(err)
+	require.NoError(tx2.Initialize(txs.Codec))
 
 	txHeap.Add(tx2)
 	require.Equal(utx2.EndTime(), txHeap.Timestamp())
diff --git a/vms/platformvm/vm_regression_test.go b/vms/platformvm/vm_regression_test.go
index d8bedcd78534..6a81de2d6348 100644
--- a/vms/platformvm/vm_regression_test.go
+++ b/vms/platformvm/vm_regression_test.go
@@ -205,8 +205,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) {
 
 			vm.ctx.Lock.Lock()
 			defer func() {
-				err := vm.Shutdown(context.Background())
-				require.NoError(err)
+				require.NoError(vm.Shutdown(context.Background()))
 
 				vm.ctx.Lock.Unlock()
 			}()
@@ -231,8 +230,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) {
 			require.NoError(err)
 
 			// issue the add validator tx
-			err = vm.Builder.AddUnverifiedTx(addValidatorTx)
-			require.NoError(err)
+			require.NoError(vm.Builder.AddUnverifiedTx(addValidatorTx))
 
 			// trigger block creation for the validator tx
 			addValidatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -254,8 +252,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) {
 			require.NoError(err)
 
 			// issue the first add delegator tx
-			err = vm.Builder.AddUnverifiedTx(addFirstDelegatorTx)
-			require.NoError(err)
+			require.NoError(vm.Builder.AddUnverifiedTx(addFirstDelegatorTx))
 
 			// trigger block creation for the first add delegator tx
 			addFirstDelegatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -277,8 +274,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) {
 			require.NoError(err)
 
 			// issue the second add delegator tx
-			err = vm.Builder.AddUnverifiedTx(addSecondDelegatorTx)
-			require.NoError(err)
+			require.NoError(vm.Builder.AddUnverifiedTx(addSecondDelegatorTx))
 
 			// trigger block creation for the second add delegator tx
 			addSecondDelegatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -300,8 +296,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) {
 			require.NoError(err)
 
 			// issue the third add delegator tx
-			err = vm.Builder.AddUnverifiedTx(addThirdDelegatorTx)
-			require.NoError(err)
+			require.NoError(vm.Builder.AddUnverifiedTx(addThirdDelegatorTx))
 
 			// trigger block creation for the third add delegator tx
 			addThirdDelegatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -323,8 +318,7 @@ func TestAddDelegatorTxHeapCorruption(t *testing.T) {
 			require.NoError(err)
 
 			// issue the fourth add delegator tx
-			err = vm.Builder.AddUnverifiedTx(addFourthDelegatorTx)
-			require.NoError(err)
+			require.NoError(vm.Builder.AddUnverifiedTx(addFourthDelegatorTx))
 
 			// trigger block creation for the fourth add delegator tx
 			addFourthDelegatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -366,7 +360,7 @@ func TestUnverifiedParentPanicRegression(t *testing.T) {
 	}()
 
 	msgChan := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		baseDBManager,
@@ -376,8 +370,7 @@ func TestUnverifiedParentPanicRegression(t *testing.T) {
 		msgChan,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	m := atomic.NewMemory(atomicDB)
 	vm.ctx.SharedMemory = m.NewSharedMemory(ctx.ChainID)
@@ -471,8 +464,7 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) {
 	vm, baseDB, mutableSharedMemory := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 
 		vm.ctx.Lock.Unlock()
 	}()
@@ -515,8 +507,7 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) {
 	require.NoError(err)
 
 	addValidatorStandardBlk := vm.manager.NewBlock(statelessBlk)
-	err = addValidatorStandardBlk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(addValidatorStandardBlk.Verify(context.Background()))
 
 	// Verify that the new validator now in pending validator set
 	{
@@ -559,10 +550,9 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) {
 		},
 	}
 	signedImportTx := &txs.Tx{Unsigned: unsignedImportTx}
-	err = signedImportTx.Sign(txs.Codec, [][]*secp256k1.PrivateKey{
+	require.NoError(signedImportTx.Sign(txs.Codec, [][]*secp256k1.PrivateKey{
 		{}, // There is one input, with no required signers
-	})
-	require.NoError(err)
+	}))
 
 	// Create the standard block that will fail verification, and then be
 	// re-verified.
@@ -600,7 +590,7 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) {
 	require.NoError(err)
 
 	inputID := utxo.InputID()
-	err = peerSharedMemory.Apply(
+	require.NoError(peerSharedMemory.Apply(
 		map[ids.ID]*atomic.Requests{
 			vm.ctx.ChainID: {
 				PutRequests: []*atomic.Element{
@@ -611,13 +601,11 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) {
 				},
 			},
 		},
-	)
-	require.NoError(err)
+	))
 
 	// Because the shared memory UTXO has now been populated, the block should
 	// pass verification.
-	err = importBlk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(importBlk.Verify(context.Background()))
 
 	// The status shouldn't have been changed during a successful verification.
 	importBlkStatus = importBlk.Status()
@@ -641,8 +629,7 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) {
 	require.NoError(err)
 
 	advanceTimeStandardBlk := vm.manager.NewBlock(statelessAdvanceTimeStandardBlk)
-	err = advanceTimeStandardBlk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(advanceTimeStandardBlk.Verify(context.Background()))
 
 	// Accept all the blocks
 	allBlocks := []snowman.Block{
@@ -651,8 +638,7 @@ func TestRejectedStateRegressionInvalidValidatorTimestamp(t *testing.T) {
 		advanceTimeStandardBlk,
 	}
 	for _, blk := range allBlocks {
-		err = blk.Accept(context.Background())
-		require.NoError(err)
+		require.NoError(blk.Accept(context.Background()))
 
 		status := blk.Status()
 		require.Equal(choices.Accepted, status)
@@ -693,8 +679,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) {
 	vm, baseDB, mutableSharedMemory := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 
 		vm.ctx.Lock.Unlock()
 	}()
@@ -736,8 +721,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) {
 	require.NoError(err)
 
 	addValidatorStandardBlk0 := vm.manager.NewBlock(statelessAddValidatorStandardBlk0)
-	err = addValidatorStandardBlk0.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(addValidatorStandardBlk0.Verify(context.Background()))
 
 	// Verify that first new validator now in pending validator set
 	{
@@ -766,8 +750,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) {
 	require.NoError(err)
 
 	advanceTimeStandardBlk0 := vm.manager.NewBlock(statelessAdvanceTimeStandardBlk0)
-	err = advanceTimeStandardBlk0.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(advanceTimeStandardBlk0.Verify(context.Background()))
 
 	// Verify that the first new validator is now in the current validator set.
 	{
@@ -816,10 +799,9 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) {
 		},
 	}
 	signedImportTx := &txs.Tx{Unsigned: unsignedImportTx}
-	err = signedImportTx.Sign(txs.Codec, [][]*secp256k1.PrivateKey{
+	require.NoError(signedImportTx.Sign(txs.Codec, [][]*secp256k1.PrivateKey{
 		{}, // There is one input, with no required signers
-	})
-	require.NoError(err)
+	}))
 
 	// Create the standard block that will fail verification, and then be
 	// re-verified.
@@ -856,7 +838,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) {
 	require.NoError(err)
 
 	inputID := utxo.InputID()
-	err = peerSharedMemory.Apply(
+	require.NoError(peerSharedMemory.Apply(
 		map[ids.ID]*atomic.Requests{
 			vm.ctx.ChainID: {
 				PutRequests: []*atomic.Element{
@@ -867,13 +849,11 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) {
 				},
 			},
 		},
-	)
-	require.NoError(err)
+	))
 
 	// Because the shared memory UTXO has now been populated, the block should
 	// pass verification.
-	err = importBlk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(importBlk.Verify(context.Background()))
 
 	// The status shouldn't have been changed during a successful verification.
 	importBlkStatus = importBlk.Status()
@@ -912,8 +892,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) {
 
 	addValidatorStandardBlk1 := vm.manager.NewBlock(statelessAddValidatorStandardBlk1)
 
-	err = addValidatorStandardBlk1.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(addValidatorStandardBlk1.Verify(context.Background()))
 
 	// Verify that the second new validator now in pending validator set
 	{
@@ -942,8 +921,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) {
 	require.NoError(err)
 
 	advanceTimeStandardBlk1 := vm.manager.NewBlock(statelessAdvanceTimeStandardBlk1)
-	err = advanceTimeStandardBlk1.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(advanceTimeStandardBlk1.Verify(context.Background()))
 
 	// Verify that the second new validator is now in the current validator set.
 	{
@@ -969,8 +947,7 @@ func TestRejectedStateRegressionInvalidValidatorReward(t *testing.T) {
 		advanceTimeStandardBlk1,
 	}
 	for _, blk := range allBlocks {
-		err = blk.Accept(context.Background())
-		require.NoError(err)
+		require.NoError(blk.Accept(context.Background()))
 
 		status := blk.Status()
 		require.Equal(choices.Accepted, status)
@@ -1020,8 +997,7 @@ func TestValidatorSetAtCacheOverwriteRegression(t *testing.T) {
 	vm, _, _ := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 
 		vm.ctx.Lock.Unlock()
 	}()
@@ -1168,8 +1144,7 @@ func TestAddDelegatorTxAddBeforeRemove(t *testing.T) {
 
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 
 		vm.ctx.Lock.Unlock()
 	}()
@@ -1194,8 +1169,7 @@ func TestAddDelegatorTxAddBeforeRemove(t *testing.T) {
 	require.NoError(err)
 
 	// issue the add validator tx
-	err = vm.Builder.AddUnverifiedTx(addValidatorTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(addValidatorTx))
 
 	// trigger block creation for the validator tx
 	addValidatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -1217,8 +1191,7 @@ func TestAddDelegatorTxAddBeforeRemove(t *testing.T) {
 	require.NoError(err)
 
 	// issue the first add delegator tx
-	err = vm.Builder.AddUnverifiedTx(addFirstDelegatorTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(addFirstDelegatorTx))
 
 	// trigger block creation for the first add delegator tx
 	addFirstDelegatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -1255,8 +1228,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t
 
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 
 		vm.ctx.Lock.Unlock()
 	}()
@@ -1279,8 +1251,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(addValidatorTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(addValidatorTx))
 
 	// trigger block creation for the validator tx
 	addValidatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -1297,8 +1268,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(createSubnetTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(createSubnetTx))
 
 	// trigger block creation for the subnet tx
 	createSubnetBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -1318,8 +1288,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(addSubnetValidatorTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(addSubnetValidatorTx))
 
 	// trigger block creation for the validator tx
 	addSubnetValidatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -1348,8 +1317,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionNotTracked(t
 	// validator set into the current validator set.
 	vm.clock.Set(validatorStartTime)
 
-	err = vm.Builder.AddUnverifiedTx(removeSubnetValidatorTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(removeSubnetValidatorTx))
 
 	// trigger block creation for the validator tx
 	removeSubnetValidatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -1377,8 +1345,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t
 
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 
 		vm.ctx.Lock.Unlock()
 	}()
@@ -1401,8 +1368,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(addValidatorTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(addValidatorTx))
 
 	// trigger block creation for the validator tx
 	addValidatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -1419,8 +1385,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(createSubnetTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(createSubnetTx))
 
 	// trigger block creation for the subnet tx
 	createSubnetBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -1431,8 +1396,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t
 
 	vm.TrackedSubnets.Add(createSubnetTx.ID())
 	subnetValidators := validators.NewSet()
-	err = vm.state.ValidatorSet(createSubnetTx.ID(), subnetValidators)
-	require.NoError(err)
+	require.NoError(vm.state.ValidatorSet(createSubnetTx.ID(), subnetValidators))
 
 	added := vm.Validators.Add(createSubnetTx.ID(), subnetValidators)
 	require.True(added)
@@ -1448,8 +1412,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(addSubnetValidatorTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(addSubnetValidatorTx))
 
 	// trigger block creation for the validator tx
 	addSubnetValidatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -1470,8 +1433,7 @@ func TestRemovePermissionedValidatorDuringPendingToCurrentTransitionTracked(t *t
 	// validator set into the current validator set.
 	vm.clock.Set(validatorStartTime)
 
-	err = vm.Builder.AddUnverifiedTx(removeSubnetValidatorTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(removeSubnetValidatorTx))
 
 	// trigger block creation for the validator tx
 	removeSubnetValidatorBlock, err := vm.Builder.BuildBlock(context.Background())
diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go
index 3edcac2cc307..12a34755de9b 100644
--- a/vms/platformvm/vm_test.go
+++ b/vms/platformvm/vm_test.go
@@ -298,8 +298,7 @@ func BuildGenesisTestWithArgs(t *testing.T, args *api.BuildGenesisArgs) (*api.Bu
 
 	buildGenesisResponse := api.BuildGenesisReply{}
 	platformvmSS := api.StaticService{}
-	err := platformvmSS.BuildGenesis(nil, &buildGenesisArgs, &buildGenesisResponse)
-	require.NoError(err)
+	require.NoError(platformvmSS.BuildGenesis(nil, &buildGenesisArgs, &buildGenesisResponse))
 
 	genesisBytes, err := formatting.Decode(buildGenesisResponse.Encoding, buildGenesisResponse.Bytes)
 	require.NoError(err)
@@ -403,8 +402,8 @@ func defaultVM() (*VM, database.Database, *mutableSharedMemory) {
 
 func GenesisVMWithArgs(t *testing.T, args *api.BuildGenesisArgs) ([]byte, chan common.Message, *VM, *atomic.Memory) {
 	require := require.New(t)
-	var genesisBytes []byte
 
+	var genesisBytes []byte
 	if args != nil {
 		_, genesisBytes = BuildGenesisTestWithArgs(t, args)
 	} else {
@@ -447,7 +446,7 @@ func GenesisVMWithArgs(t *testing.T, args *api.BuildGenesisArgs) ([]byte, chan c
 	appSender.SendAppGossipF = func(context.Context, []byte) error {
 		return nil
 	}
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		chainDBManager,
@@ -457,13 +456,14 @@ func GenesisVMWithArgs(t *testing.T, args *api.BuildGenesisArgs) ([]byte, chan c
 		msgChan,
 		nil,
 		appSender,
-	)
-	require.NoError(err)
+	))
 
-	err = vm.SetState(context.Background(), snow.NormalOp)
-	require.NoError(err)
+	require.NoError(vm.SetState(context.Background(), snow.NormalOp))
 
 	// Create a subnet and store it in testSubnet1
+	// Note: testSubnet1 is a global and should be set when calling this
+	// function.
+	var err error
 	testSubnet1, err = vm.txBuilder.NewCreateSubnetTx(
 		2, // threshold; 2 sigs from keys[0], keys[1], keys[2] needed to add validator to this subnet
 		// control keys are keys[0], keys[1], keys[2]
@@ -473,17 +473,14 @@ func GenesisVMWithArgs(t *testing.T, args *api.BuildGenesisArgs) ([]byte, chan c
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(testSubnet1)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(testSubnet1))
 
 	blk, err := vm.Builder.BuildBlock(context.Background())
 	require.NoError(err)
 
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 
-	err = blk.Accept(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Accept(context.Background()))
 
 	return genesisBytes, msgChan, vm, m
 }
@@ -494,8 +491,7 @@ func TestGenesis(t *testing.T) {
 	vm, _, _ := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 		vm.ctx.Lock.Unlock()
 	}()
 
@@ -602,8 +598,7 @@ func TestInvalidAddValidatorCommit(t *testing.T) {
 	vm, _, _ := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 		vm.ctx.Lock.Unlock()
 	}()
 
@@ -701,8 +696,7 @@ func TestAddValidatorInvalidNotReissued(t *testing.T) {
 	vm, _, _ := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 		vm.ctx.Lock.Unlock()
 	}()
 
@@ -1105,8 +1099,7 @@ func TestUnneededBuildBlock(t *testing.T) {
 	vm, _, _ := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 		vm.ctx.Lock.Unlock()
 	}()
 	_, err := vm.Builder.BuildBlock(context.Background())
@@ -1119,8 +1112,7 @@ func TestCreateChain(t *testing.T) {
 	vm, _, _ := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 		vm.ctx.Lock.Unlock()
 	}()
 
@@ -1135,17 +1127,14 @@ func TestCreateChain(t *testing.T) {
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(tx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(tx))
 
 	blk, err := vm.Builder.BuildBlock(context.Background())
 	require.NoError(err) // should contain proposal to create chain
 
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 
-	err = blk.Accept(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Accept(context.Background()))
 
 	_, txStatus, err := vm.state.GetTx(tx.ID())
 	require.NoError(err)
@@ -1285,8 +1274,7 @@ func TestAtomicImport(t *testing.T) {
 	vm, baseDB, mutableSharedMemory := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 		vm.ctx.Lock.Unlock()
 	}()
 
@@ -1327,7 +1315,7 @@ func TestAtomicImport(t *testing.T) {
 	require.NoError(err)
 
 	inputID := utxo.InputID()
-	err = peerSharedMemory.Apply(map[ids.ID]*atomic.Requests{
+	require.NoError(peerSharedMemory.Apply(map[ids.ID]*atomic.Requests{
 		vm.ctx.ChainID: {
 			PutRequests: []*atomic.Element{
 				{
@@ -1339,9 +1327,7 @@ func TestAtomicImport(t *testing.T) {
 				},
 			},
 		},
-	},
-	)
-	require.NoError(err)
+	}))
 
 	tx, err := vm.txBuilder.NewImportTx(
 		vm.ctx.XChainID,
@@ -1351,17 +1337,14 @@ func TestAtomicImport(t *testing.T) {
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(tx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(tx))
 
 	blk, err := vm.Builder.BuildBlock(context.Background())
 	require.NoError(err)
 
-	err = blk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Verify(context.Background()))
 
-	err = blk.Accept(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Accept(context.Background()))
 
 	_, txStatus, err := vm.state.GetTx(tx.ID())
 	require.NoError(err)
@@ -1378,8 +1361,7 @@ func TestOptimisticAtomicImport(t *testing.T) {
 	vm, _, _ := defaultVM()
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 		vm.ctx.Lock.Unlock()
 	}()
 
@@ -1400,8 +1382,7 @@ func TestOptimisticAtomicImport(t *testing.T) {
 			},
 		}},
 	}}
-	err := tx.Initialize(txs.Codec)
-	require.NoError(err)
+	require.NoError(tx.Initialize(txs.Codec))
 
 	preferred, err := vm.Builder.Preferred()
 	require.NoError(err)
@@ -1421,17 +1402,13 @@ func TestOptimisticAtomicImport(t *testing.T) {
 	err = blk.Verify(context.Background())
 	require.ErrorIs(err, database.ErrNotFound) // erred due to missing shared memory UTXOs
 
-	err = vm.SetState(context.Background(), snow.Bootstrapping)
-	require.NoError(err)
+	require.NoError(vm.SetState(context.Background(), snow.Bootstrapping))
 
-	err = blk.Verify(context.Background())
-	require.NoError(err) // skips shared memory UTXO verification during bootstrapping
+	require.NoError(blk.Verify(context.Background())) // skips shared memory UTXO verification during bootstrapping
 
-	err = blk.Accept(context.Background())
-	require.NoError(err)
+	require.NoError(blk.Accept(context.Background()))
 
-	err = vm.SetState(context.Background(), snow.NormalOp)
-	require.NoError(err)
+	require.NoError(vm.SetState(context.Background(), snow.NormalOp))
 
 	_, txStatus, err := vm.state.GetTx(tx.ID())
 	require.NoError(err)
@@ -1474,7 +1451,7 @@ func TestRestartFullyAccepted(t *testing.T) {
 	firstCtx.Lock.Lock()
 
 	firstMsgChan := make(chan common.Message, 1)
-	err := firstVM.Initialize(
+	require.NoError(firstVM.Initialize(
 		context.Background(),
 		firstCtx,
 		firstDB,
@@ -1484,8 +1461,7 @@ func TestRestartFullyAccepted(t *testing.T) {
 		firstMsgChan,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	genesisID, err := firstVM.LastAccepted(context.Background())
 	require.NoError(err)
@@ -1553,14 +1529,13 @@ func TestRestartFullyAccepted(t *testing.T) {
 	secondVM.clock.Set(initialClkTime)
 	secondCtx.Lock.Lock()
 	defer func() {
-		err := secondVM.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(secondVM.Shutdown(context.Background()))
 		secondCtx.Lock.Unlock()
 	}()
 
 	secondDB := db.NewPrefixDBManager([]byte{})
 	secondMsgChan := make(chan common.Message, 1)
-	err = secondVM.Initialize(
+	require.NoError(secondVM.Initialize(
 		context.Background(),
 		secondCtx,
 		secondDB,
@@ -1570,8 +1545,7 @@ func TestRestartFullyAccepted(t *testing.T) {
 		secondMsgChan,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	lastAccepted, err := secondVM.LastAccepted(context.Background())
 	require.NoError(err)
@@ -1620,7 +1594,7 @@ func TestBootstrapPartiallyAccepted(t *testing.T) {
 	ctx.Lock.Lock()
 
 	msgChan := make(chan common.Message, 1)
-	err = vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		vmDBManager,
@@ -1630,8 +1604,7 @@ func TestBootstrapPartiallyAccepted(t *testing.T) {
 		msgChan,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	preferred, err := vm.Builder.Preferred()
 	require.NoError(err)
@@ -1700,7 +1673,7 @@ func TestBootstrapPartiallyAccepted(t *testing.T) {
 	mc, err := message.NewCreator(logging.NoLog{}, metrics, "dummyNamespace", constants.DefaultNetworkCompressionType, 10*time.Second)
 	require.NoError(err)
 
-	err = chainRouter.Initialize(
+	require.NoError(chainRouter.Initialize(
 		ids.EmptyNodeID,
 		logging.NoLog{},
 		timeoutManager,
@@ -1712,8 +1685,7 @@ func TestBootstrapPartiallyAccepted(t *testing.T) {
 		router.HealthConfig{},
 		"",
 		prometheus.NewRegistry(),
-	)
-	require.NoError(err)
+	))
 
 	externalSender := &sender.ExternalSenderTest{TB: t}
 	externalSender.Default(true)
@@ -1862,8 +1834,7 @@ func TestBootstrapPartiallyAccepted(t *testing.T) {
 	h.Start(context.Background(), false)
 
 	ctx.Lock.Lock()
-	err = bootstrapper.Connected(context.Background(), peerID, version.CurrentApp)
-	require.NoError(err)
+	require.NoError(bootstrapper.Connected(context.Background(), peerID, version.CurrentApp))
 
 	externalSender.SendF = func(msg message.OutboundMessage, nodeIDs set.Set[ids.NodeID], _ ids.ID, _ subnets.Allower) set.Set[ids.NodeID] {
 		inMsgIntf, err := mc.Parse(msg.Bytes(), ctx.NodeID, func() {})
@@ -1876,8 +1847,7 @@ func TestBootstrapPartiallyAccepted(t *testing.T) {
 	}
 
 	frontier := []ids.ID{advanceTimeBlkID}
-	err = bootstrapper.AcceptedFrontier(context.Background(), peerID, reqID, frontier)
-	require.NoError(err)
+	require.NoError(bootstrapper.AcceptedFrontier(context.Background(), peerID, reqID, frontier))
 
 	externalSender.SendF = func(msg message.OutboundMessage, nodeIDs set.Set[ids.NodeID], _ ids.ID, _ subnets.Allower) set.Set[ids.NodeID] {
 		inMsgIntf, err := mc.Parse(msg.Bytes(), ctx.NodeID, func() {})
@@ -1937,7 +1907,7 @@ func TestUnverifiedParent(t *testing.T) {
 	}()
 
 	msgChan := make(chan common.Message, 1)
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		dbManager,
@@ -1947,8 +1917,7 @@ func TestUnverifiedParent(t *testing.T) {
 		msgChan,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	// include a tx1 to make the block be accepted
 	tx1 := &txs.Tx{Unsigned: &txs.ImportTx{
@@ -1984,8 +1953,7 @@ func TestUnverifiedParent(t *testing.T) {
 	)
 	require.NoError(err)
 	firstAdvanceTimeBlk := vm.manager.NewBlock(statelessBlk)
-	err = firstAdvanceTimeBlk.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(firstAdvanceTimeBlk.Verify(context.Background()))
 
 	// include a tx1 to make the block be accepted
 	tx2 := &txs.Tx{Unsigned: &txs.ImportTx{
@@ -2093,7 +2061,7 @@ func TestUptimeDisallowedWithRestart(t *testing.T) {
 	firstCtx.Lock.Lock()
 
 	firstMsgChan := make(chan common.Message, 1)
-	err := firstVM.Initialize(
+	require.NoError(firstVM.Initialize(
 		context.Background(),
 		firstCtx,
 		firstDB,
@@ -2103,8 +2071,7 @@ func TestUptimeDisallowedWithRestart(t *testing.T) {
 		firstMsgChan,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	initialClkTime := banffForkTime.Add(time.Second)
 	firstVM.clock.Set(initialClkTime)
@@ -2139,7 +2106,7 @@ func TestUptimeDisallowedWithRestart(t *testing.T) {
 	}()
 
 	secondMsgChan := make(chan common.Message, 1)
-	err = secondVM.Initialize(
+	require.NoError(secondVM.Initialize(
 		context.Background(),
 		secondCtx,
 		secondDB,
@@ -2149,8 +2116,7 @@ func TestUptimeDisallowedWithRestart(t *testing.T) {
 		secondMsgChan,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	secondVM.clock.Set(defaultValidateStartTime.Add(2 * defaultMinStakingDuration))
 	secondVM.uptimeManager.(uptime.TestManager).SetTime(defaultValidateStartTime.Add(2 * defaultMinStakingDuration))
@@ -2269,7 +2235,7 @@ func TestUptimeDisallowedAfterNeverConnecting(t *testing.T) {
 
 	msgChan := make(chan common.Message, 1)
 	appSender := &common.SenderTest{T: t}
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		db,
@@ -2279,8 +2245,7 @@ func TestUptimeDisallowedAfterNeverConnecting(t *testing.T) {
 		msgChan,
 		nil,
 		appSender,
-	)
-	require.NoError(err)
+	))
 
 	defer func() {
 		require.NoError(vm.Shutdown(context.Background()))
@@ -2363,8 +2328,7 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) {
 
 	vm.ctx.Lock.Lock()
 	defer func() {
-		err := vm.Shutdown(context.Background())
-		require.NoError(err)
+		require.NoError(vm.Shutdown(context.Background()))
 
 		vm.ctx.Lock.Unlock()
 	}()
@@ -2386,8 +2350,7 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) {
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(addValidatorTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(addValidatorTx))
 
 	// trigger block creation for the validator tx
 	addValidatorBlock, err := vm.Builder.BuildBlock(context.Background())
@@ -2404,8 +2367,7 @@ func TestRemovePermissionedValidatorDuringAddPending(t *testing.T) {
 	)
 	require.NoError(err)
 
-	err = vm.Builder.AddUnverifiedTx(createSubnetTx)
-	require.NoError(err)
+	require.NoError(vm.Builder.AddUnverifiedTx(createSubnetTx))
 
 	// trigger block creation for the subnet tx
 	createSubnetBlock, err := vm.Builder.BuildBlock(context.Background())
diff --git a/vms/proposervm/block/build_test.go b/vms/proposervm/block/build_test.go
index a4136c7089ca..e6ec488eb482 100644
--- a/vms/proposervm/block/build_test.go
+++ b/vms/proposervm/block/build_test.go
@@ -45,8 +45,7 @@ func TestBuild(t *testing.T) {
 	require.Equal(timestamp, builtBlock.Timestamp())
 	require.Equal(innerBlockBytes, builtBlock.Block())
 
-	err = builtBlock.Verify(true, chainID)
-	require.NoError(err)
+	require.NoError(builtBlock.Verify(true, chainID))
 
 	err = builtBlock.Verify(false, chainID)
 	require.ErrorIs(err, errUnexpectedProposer)
@@ -69,8 +68,7 @@ func TestBuildUnsigned(t *testing.T) {
 	require.Equal(innerBlockBytes, builtBlock.Block())
 	require.Equal(ids.EmptyNodeID, builtBlock.Proposer())
 
-	err = builtBlock.Verify(false, ids.Empty)
-	require.NoError(err)
+	require.NoError(builtBlock.Verify(false, ids.Empty))
 
 	err = builtBlock.Verify(true, ids.Empty)
 	require.ErrorIs(err, errMissingProposer)
diff --git a/vms/proposervm/state_syncable_vm_test.go b/vms/proposervm/state_syncable_vm_test.go
index f8f7e0401aee..5e5572edb7aa 100644
--- a/vms/proposervm/state_syncable_vm_test.go
+++ b/vms/proposervm/state_syncable_vm_test.go
@@ -86,7 +86,7 @@ func helperBuildStateSyncTestObjects(t *testing.T) (*fullVM, *VM) {
 	ctx := snow.DefaultContextTest()
 	ctx.NodeID = ids.NodeIDFromCert(pTestCert.Leaf)
 
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		dbManager,
@@ -96,8 +96,7 @@ func helperBuildStateSyncTestObjects(t *testing.T) (*fullVM, *VM) {
 		nil,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	return innerVM, vm
 }
diff --git a/vms/proposervm/tree/tree_test.go b/vms/proposervm/tree/tree_test.go
index 979943b86770..4bd992cd2212 100644
--- a/vms/proposervm/tree/tree_test.go
+++ b/vms/proposervm/tree/tree_test.go
@@ -43,8 +43,7 @@ func TestAcceptSingleBlock(t *testing.T) {
 	_, contains = tr.Get(block)
 	require.True(contains)
 
-	err := tr.Accept(context.Background(), block)
-	require.NoError(err)
+	require.NoError(tr.Accept(context.Background(), block))
 	require.Equal(choices.Accepted, block.Status())
 }
 
@@ -78,8 +77,7 @@ func TestAcceptBlockConflict(t *testing.T) {
 	_, contains = tr.Get(blockToReject)
 	require.True(contains)
 
-	err := tr.Accept(context.Background(), blockToAccept)
-	require.NoError(err)
+	require.NoError(tr.Accept(context.Background(), blockToAccept))
 	require.Equal(choices.Accepted, blockToAccept.Status())
 	require.Equal(choices.Rejected, blockToReject.Status())
 }
@@ -126,8 +124,7 @@ func TestAcceptChainConflict(t *testing.T) {
 	_, contains = tr.Get(blockToRejectChild)
 	require.True(contains)
 
-	err := tr.Accept(context.Background(), blockToAccept)
-	require.NoError(err)
+	require.NoError(tr.Accept(context.Background(), blockToAccept))
 	require.Equal(choices.Accepted, blockToAccept.Status())
 	require.Equal(choices.Rejected, blockToReject.Status())
 	require.Equal(choices.Rejected, blockToRejectChild.Status())
diff --git a/vms/proposervm/vm_test.go b/vms/proposervm/vm_test.go
index a9b45f505ab6..1c9f339a37f6 100644
--- a/vms/proposervm/vm_test.go
+++ b/vms/proposervm/vm_test.go
@@ -2006,7 +2006,7 @@ func TestRejectedHeightNotIndexed(t *testing.T) {
 	dummyDBManager := manager.NewMemDB(version.Semantic1_0_0)
 	// make sure that DBs are compressed correctly
 	dummyDBManager = dummyDBManager.NewPrefixDBManager([]byte{})
-	err := proVM.Initialize(
+	require.NoError(proVM.Initialize(
 		context.Background(),
 		ctx,
 		dummyDBManager,
@@ -2016,17 +2016,14 @@ func TestRejectedHeightNotIndexed(t *testing.T) {
 		nil,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	// Initialize shouldn't be called again
 	coreVM.InitializeF = nil
 
-	err = proVM.SetState(context.Background(), snow.NormalOp)
-	require.NoError(err)
+	require.NoError(proVM.SetState(context.Background(), snow.NormalOp))
 
-	err = proVM.SetPreference(context.Background(), coreGenBlk.IDV)
-	require.NoError(err)
+	require.NoError(proVM.SetPreference(context.Background(), coreGenBlk.IDV))
 
 	ctx.Lock.Lock()
 	for proVM.VerifyHeightIndex(context.Background()) != nil {
@@ -2055,8 +2052,7 @@ func TestRejectedHeightNotIndexed(t *testing.T) {
 	require.NoError(err)
 
 	coreVM.BuildBlockF = nil
-	err = aBlock.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(aBlock.Verify(context.Background()))
 
 	// use a different way to construct inner block Y and outer block B
 	yBlock := &snowman.TestBlock{
@@ -2087,12 +2083,10 @@ func TestRejectedHeightNotIndexed(t *testing.T) {
 		},
 	}
 
-	err = bBlock.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(bBlock.Verify(context.Background()))
 
 	// accept A
-	err = aBlock.Accept(context.Background())
-	require.NoError(err)
+	require.NoError(aBlock.Accept(context.Background()))
 	coreHeights = append(coreHeights, xBlock.ID())
 
 	blkID, err := proVM.GetBlockIDAtHeight(context.Background(), aBlock.Height())
@@ -2100,8 +2094,7 @@ func TestRejectedHeightNotIndexed(t *testing.T) {
 	require.Equal(aBlock.ID(), blkID)
 
 	// reject B
-	err = bBlock.Reject(context.Background())
-	require.NoError(err)
+	require.NoError(bBlock.Reject(context.Background()))
 
 	blkID, err = proVM.GetBlockIDAtHeight(context.Background(), aBlock.Height())
 	require.NoError(err)
@@ -2221,7 +2214,7 @@ func TestRejectedOptionHeightNotIndexed(t *testing.T) {
 	dummyDBManager := manager.NewMemDB(version.Semantic1_0_0)
 	// make sure that DBs are compressed correctly
 	dummyDBManager = dummyDBManager.NewPrefixDBManager([]byte{})
-	err := proVM.Initialize(
+	require.NoError(proVM.Initialize(
 		context.Background(),
 		ctx,
 		dummyDBManager,
@@ -2231,17 +2224,14 @@ func TestRejectedOptionHeightNotIndexed(t *testing.T) {
 		nil,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	// Initialize shouldn't be called again
 	coreVM.InitializeF = nil
 
-	err = proVM.SetState(context.Background(), snow.NormalOp)
-	require.NoError(err)
+	require.NoError(proVM.SetState(context.Background(), snow.NormalOp))
 
-	err = proVM.SetPreference(context.Background(), coreGenBlk.IDV)
-	require.NoError(err)
+	require.NoError(proVM.SetPreference(context.Background(), coreGenBlk.IDV))
 
 	ctx.Lock.Lock()
 	for proVM.VerifyHeightIndex(context.Background()) != nil {
@@ -2296,20 +2286,16 @@ func TestRejectedOptionHeightNotIndexed(t *testing.T) {
 	opts, err := aBlock.Options(context.Background())
 	require.NoError(err)
 
-	err = aBlock.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(aBlock.Verify(context.Background()))
 
 	bBlock := opts[0]
-	err = bBlock.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(bBlock.Verify(context.Background()))
 
 	cBlock := opts[1]
-	err = cBlock.Verify(context.Background())
-	require.NoError(err)
+	require.NoError(cBlock.Verify(context.Background()))
 
 	// accept A
-	err = aBlock.Accept(context.Background())
-	require.NoError(err)
+	require.NoError(aBlock.Accept(context.Background()))
 	coreHeights = append(coreHeights, xBlock.ID())
 
 	blkID, err := proVM.GetBlockIDAtHeight(context.Background(), aBlock.Height())
@@ -2317,8 +2303,7 @@ func TestRejectedOptionHeightNotIndexed(t *testing.T) {
 	require.Equal(aBlock.ID(), blkID)
 
 	// accept B
-	err = bBlock.Accept(context.Background())
-	require.NoError(err)
+	require.NoError(bBlock.Accept(context.Background()))
 	coreHeights = append(coreHeights, xBlock.opts[0].ID())
 
 	blkID, err = proVM.GetBlockIDAtHeight(context.Background(), bBlock.Height())
@@ -2326,8 +2311,7 @@ func TestRejectedOptionHeightNotIndexed(t *testing.T) {
 	require.Equal(bBlock.ID(), blkID)
 
 	// reject C
-	err = cBlock.Reject(context.Background())
-	require.NoError(err)
+	require.NoError(cBlock.Reject(context.Background()))
 
 	blkID, err = proVM.GetBlockIDAtHeight(context.Background(), cBlock.Height())
 	require.NoError(err)
@@ -2369,7 +2353,7 @@ func TestVMInnerBlkCache(t *testing.T) {
 	ctx := snow.DefaultContextTest()
 	ctx.NodeID = ids.NodeIDFromCert(pTestCert.Leaf)
 
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		ctx,
 		dummyDBManager,
@@ -2379,8 +2363,7 @@ func TestVMInnerBlkCache(t *testing.T) {
 		nil,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 	state := state.NewMockState(ctrl) // mock state
 	vm.State = state
 
@@ -2479,17 +2462,10 @@ func TestVMInnerBlkCacheDeduplicationRegression(t *testing.T) {
 	bBlock, err := proVM.ParseBlock(context.Background(), bBlockBytes)
 	require.NoError(err)
 
-	err = aBlock.Verify(context.Background())
-	require.NoError(err)
-
-	err = bBlock.Verify(context.Background())
-	require.NoError(err)
-
-	err = aBlock.Accept(context.Background())
-	require.NoError(err)
-
-	err = bBlock.Reject(context.Background())
-	require.NoError(err)
+	require.NoError(aBlock.Verify(context.Background()))
+	require.NoError(bBlock.Verify(context.Background()))
+	require.NoError(aBlock.Accept(context.Background()))
+	require.NoError(bBlock.Reject(context.Background()))
 
 	require.Equal(
 		choices.Accepted,
@@ -2552,7 +2528,7 @@ func TestVM_VerifyBlockWithContext(t *testing.T) {
 	snowCtx := snow.DefaultContextTest()
 	snowCtx.NodeID = ids.NodeIDFromCert(pTestCert.Leaf)
 
-	err := vm.Initialize(
+	require.NoError(vm.Initialize(
 		context.Background(),
 		snowCtx,
 		dummyDBManager,
@@ -2562,8 +2538,7 @@ func TestVM_VerifyBlockWithContext(t *testing.T) {
 		nil,
 		nil,
 		nil,
-	)
-	require.NoError(err)
+	))
 
 	{
 		pChainHeight := uint64(0)
@@ -2585,14 +2560,13 @@ func TestVM_VerifyBlockWithContext(t *testing.T) {
 		blkID := ids.GenerateTestID()
 		blk.EXPECT().ID().Return(blkID).AnyTimes()
 
-		err = vm.verifyAndRecordInnerBlk(
+		require.NoError(vm.verifyAndRecordInnerBlk(
 			context.Background(),
 			&block.Context{
 				PChainHeight: pChainHeight,
 			},
 			blk,
-		)
-		require.NoError(err)
+		))
 
 		// Call VerifyWithContext again but with a different P-Chain height
 		blk.EXPECT().setInnerBlk(innerBlk).AnyTimes()
@@ -2603,14 +2577,13 @@ func TestVM_VerifyBlockWithContext(t *testing.T) {
 			},
 		).Return(nil)
 
-		err = vm.verifyAndRecordInnerBlk(
+		require.NoError(vm.verifyAndRecordInnerBlk(
 			context.Background(),
 			&block.Context{
 				PChainHeight: pChainHeight,
 			},
 			blk,
-		)
-		require.NoError(err)
+		))
 	}
 
 	{
@@ -2628,14 +2601,13 @@ func TestVM_VerifyBlockWithContext(t *testing.T) {
 		blk.EXPECT().getInnerBlk().Return(innerBlk).AnyTimes()
 		blkID := ids.GenerateTestID()
 		blk.EXPECT().ID().Return(blkID).AnyTimes()
-		err = vm.verifyAndRecordInnerBlk(
+		require.NoError(vm.verifyAndRecordInnerBlk(
 			context.Background(),
 			&block.Context{
 				PChainHeight: 1,
 			},
 			blk,
-		)
-		require.NoError(err)
+		))
 	}
 
 	{
@@ -2651,7 +2623,6 @@ func TestVM_VerifyBlockWithContext(t *testing.T) {
 		blk.EXPECT().getInnerBlk().Return(innerBlk).AnyTimes()
 		blkID := ids.GenerateTestID()
 		blk.EXPECT().ID().Return(blkID).AnyTimes()
-		err = vm.verifyAndRecordInnerBlk(context.Background(), nil, blk)
-		require.NoError(err)
+		require.NoError(vm.verifyAndRecordInnerBlk(context.Background(), nil, blk))
 	}
 }
diff --git a/vms/rpcchainvm/batched_vm_test.go b/vms/rpcchainvm/batched_vm_test.go
index b0de0f5656e3..480be0d4c396 100644
--- a/vms/rpcchainvm/batched_vm_test.go
+++ b/vms/rpcchainvm/batched_vm_test.go
@@ -90,8 +90,7 @@ func TestBatchedParseBlockCaching(t *testing.T) {
 	ctx := snow.DefaultContextTest()
 	dbManager := manager.NewMemDB(version.Semantic1_0_0)
 
-	err := vm.Initialize(context.Background(), ctx, dbManager, nil, nil, nil, nil, nil, nil)
-	require.NoError(err)
+	require.NoError(vm.Initialize(context.Background(), ctx, dbManager, nil, nil, nil, nil, nil, nil))
 
 	// Call should parse the first block
 	blk, err := vm.ParseBlock(context.Background(), blkBytes1)
diff --git a/vms/rpcchainvm/ghttp/http_test.go b/vms/rpcchainvm/ghttp/http_test.go
index 7cafe62a56ed..2bcf5f3150d8 100644
--- a/vms/rpcchainvm/ghttp/http_test.go
+++ b/vms/rpcchainvm/ghttp/http_test.go
@@ -13,8 +13,6 @@ import (
 )
 
 func TestConvertWriteResponse(t *testing.T) {
-	require := require.New(t)
-
 	scenerios := map[string]struct {
 		resp *httppb.HandleSimpleHTTPResponse
 	}{
@@ -47,8 +45,7 @@ func TestConvertWriteResponse(t *testing.T) {
 	for testName, scenerio := range scenerios {
 		t.Run(testName, func(t *testing.T) {
 			w := httptest.NewRecorder()
-			err := convertWriteResponse(w, scenerio.resp)
-			require.NoError(err)
+			require.NoError(t, convertWriteResponse(w, scenerio.resp))
 		})
 	}
 }
diff --git a/vms/rpcchainvm/grpcutils/client_test.go b/vms/rpcchainvm/grpcutils/client_test.go
index 0e48a837c4e4..c19fa4989440 100644
--- a/vms/rpcchainvm/grpcutils/client_test.go
+++ b/vms/rpcchainvm/grpcutils/client_test.go
@@ -61,8 +61,7 @@ func TestWaitForReady(t *testing.T) {
 
 	db := rpcdb.NewClient(pb.NewDatabaseClient(conn))
 
-	err = db.Put([]byte("foo"), []byte("bar"))
-	require.NoError(err)
+	require.NoError(db.Put([]byte("foo"), []byte("bar")))
 
 	noWaitListener, err := NewListener()
 	require.NoError(err)
diff --git a/vms/rpcchainvm/vm_test.go b/vms/rpcchainvm/vm_test.go
index 5c1953d3216c..968a04fe0b05 100644
--- a/vms/rpcchainvm/vm_test.go
+++ b/vms/rpcchainvm/vm_test.go
@@ -181,8 +181,7 @@ func TestRuntimeSubprocessBootstrap(t *testing.T) {
 			listener, err := grpcutils.NewListener()
 			require.NoError(err)
 
-			err = os.Setenv(runtime.EngineAddressKey, listener.Addr().String())
-			require.NoError(err)
+			require.NoError(os.Setenv(runtime.EngineAddressKey, listener.Addr().String()))
 
 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()
diff --git a/vms/rpcchainvm/with_context_vm_test.go b/vms/rpcchainvm/with_context_vm_test.go
index 8fd85f3067a4..28b73dcb5d05 100644
--- a/vms/rpcchainvm/with_context_vm_test.go
+++ b/vms/rpcchainvm/with_context_vm_test.go
@@ -102,8 +102,7 @@ func TestContextVMSummary(t *testing.T) {
 	ctx := snow.DefaultContextTest()
 	dbManager := manager.NewMemDB(version.Semantic1_0_0)
 
-	err := vm.Initialize(context.Background(), ctx, dbManager, nil, nil, nil, nil, nil, nil)
-	require.NoError(err)
+	require.NoError(vm.Initialize(context.Background(), ctx, dbManager, nil, nil, nil, nil, nil, nil))
 
 	blkIntf, err := vm.BuildBlockWithContext(context.Background(), blockContext)
 	require.NoError(err)
@@ -115,6 +114,5 @@ func TestContextVMSummary(t *testing.T) {
 	require.NoError(err)
 	require.True(shouldVerify)
 
-	err = blk.VerifyWithContext(context.Background(), blockContext)
-	require.NoError(err)
+	require.NoError(blk.VerifyWithContext(context.Background(), blockContext))
 }
diff --git a/x/merkledb/cache_test.go b/x/merkledb/cache_test.go
index ba66268cce0d..2aa136afb02b 100644
--- a/x/merkledb/cache_test.go
+++ b/x/merkledb/cache_test.go
@@ -28,8 +28,7 @@ func TestNewOnEvictCache(t *testing.T) {
 	require.Zero(cache.fifo.Len())
 	// Can't test function equality directly so do this
 	// to make sure it was assigned correctly
-	err := cache.onEviction(0)
-	require.NoError(err)
+	require.NoError(cache.onEviction(0))
 	require.True(called)
 }
 
@@ -53,8 +52,7 @@ func TestOnEvictCacheNoOnEvictionError(t *testing.T) {
 	require.False(ok)
 
 	// Put key
-	err := cache.Put(0, 0)
-	require.NoError(err)
+	require.NoError(cache.Put(0, 0))
 	require.Equal(1, cache.fifo.Len())
 
 	// Get key
@@ -68,8 +66,7 @@ func TestOnEvictCacheNoOnEvictionError(t *testing.T) {
 
 	// Fill the cache
 	for i := 1; i < maxSize; i++ {
-		err := cache.Put(i, i)
-		require.NoError(err)
+		require.NoError(cache.Put(i, i))
 		require.Equal(i+1, cache.fifo.Len())
 	}
 	require.Empty(evicted)
@@ -77,8 +74,7 @@ func TestOnEvictCacheNoOnEvictionError(t *testing.T) {
 	// Cache has [0,1,2]
 
 	// Put another key. This should evict the oldest inserted key (0).
-	err = cache.Put(maxSize, maxSize)
-	require.NoError(err)
+	require.NoError(cache.Put(maxSize, maxSize))
 	require.Equal(maxSize, cache.fifo.Len())
 	require.Len(evicted, 1)
 	require.Zero(evicted[0])
@@ -121,8 +117,7 @@ func TestOnEvictCacheNoOnEvictionError(t *testing.T) {
 	require.False(iter.Next())
 
 	// Put another key to evict the oldest inserted key (1).
-	err = cache.Put(maxSize+1, maxSize+1)
-	require.NoError(err)
+	require.NoError(cache.Put(maxSize+1, maxSize+1))
 	require.Equal(maxSize, cache.fifo.Len())
 	require.Len(evicted, 2)
 	require.Equal(1, evicted[1])
@@ -144,8 +139,7 @@ func TestOnEvictCacheNoOnEvictionError(t *testing.T) {
 	_, ok = cache.Get(1)
 	require.False(ok)
 
-	err = cache.Flush()
-	require.NoError(err)
+	require.NoError(cache.Flush())
 
 	// Cache should be empty
 	require.Zero(cache.fifo.Len())
@@ -177,8 +171,7 @@ func TestOnEvictCacheOnEvictionError(t *testing.T) {
 
 	// Fill the cache
 	for i := 0; i < maxSize; i++ {
-		err := cache.Put(i, i)
-		require.NoError(err)
+		require.NoError(cache.Put(i, i))
 		require.Equal(i+1, cache.fifo.Len())
 	}
 
diff --git a/x/merkledb/codec_test.go b/x/merkledb/codec_test.go
index 157f87f97fb4..50790b87df4f 100644
--- a/x/merkledb/codec_test.go
+++ b/x/merkledb/codec_test.go
@@ -138,8 +138,7 @@ func FuzzCodecBool(f *testing.F) {
 
 			// Encoding [got] should be the same as [b].
 			var buf bytes.Buffer
-			err = codec.encodeBool(&buf, got)
-			require.NoError(err)
+			require.NoError(codec.encodeBool(&buf, got))
 			bufBytes := buf.Bytes()
 			require.Len(bufBytes, numRead)
 			require.Equal(b[:numRead], bufBytes)
@@ -167,8 +166,7 @@ func FuzzCodecInt(f *testing.F) {
 
 			// Encoding [got] should be the same as [b].
 			var buf bytes.Buffer
-			err = codec.encodeInt(&buf, got)
-			require.NoError(err)
+			require.NoError(codec.encodeInt(&buf, got))
 			bufBytes := buf.Bytes()
 			require.Len(bufBytes, numRead)
 			require.Equal(b[:numRead], bufBytes)
@@ -196,8 +194,7 @@ func FuzzCodecSerializedPath(f *testing.F) {
 
 			// Encoding [got] should be the same as [b].
 			var buf bytes.Buffer
-			err = codec.encodeSerializedPath(got, &buf)
-			require.NoError(err)
+			require.NoError(codec.encodeSerializedPath(got, &buf))
 			bufBytes := buf.Bytes()
 			require.Len(bufBytes, numRead)
 			require.Equal(b[:numRead], bufBytes)
@@ -601,8 +598,7 @@ func TestCodec_DecodeChangeProof(t *testing.T) {
 
 	// Put key-values length of -1
 	proofBytesBuf := bytes.NewBuffer(proofBytes)
-	err = Codec.(*codecImpl).encodeInt(proofBytesBuf, -1)
-	require.NoError(err)
+	require.NoError(Codec.(*codecImpl).encodeInt(proofBytesBuf, -1))
 
 	_, err = Codec.DecodeChangeProof(proofBytesBuf.Bytes(), &parsedProof)
 	require.ErrorIs(err, errNegativeNumKeyValues)
@@ -634,8 +630,7 @@ func TestCodec_DecodeRangeProof(t *testing.T) {
 	proofBytes = proofBytes[:len(proofBytes)-minVarIntLen]
 	proofBytesBuf := bytes.NewBuffer(proofBytes)
 	// Put key-value length (-1) at end
-	err = Codec.(*codecImpl).encodeInt(proofBytesBuf, -1)
-	require.NoError(err)
+	require.NoError(Codec.(*codecImpl).encodeInt(proofBytesBuf, -1))
 
 	_, err = Codec.DecodeRangeProof(proofBytesBuf.Bytes(), &parsedProof)
 	require.ErrorIs(err, errNegativeNumKeyValues)
@@ -666,8 +661,7 @@ func TestCodec_DecodeDBNode(t *testing.T) {
 	nodeBytes = nodeBytes[:len(nodeBytes)-minVarIntLen]
 	proofBytesBuf := bytes.NewBuffer(nodeBytes)
 	// Put num children -1 at end
-	err = Codec.(*codecImpl).encodeInt(proofBytesBuf, -1)
-	require.NoError(err)
+	require.NoError(Codec.(*codecImpl).encodeInt(proofBytesBuf, -1))
 
 	_, err = Codec.decodeDBNode(proofBytesBuf.Bytes(), &parsedDBNode)
 	require.ErrorIs(err, errNegativeNumChildren)
@@ -677,8 +671,7 @@ func TestCodec_DecodeDBNode(t *testing.T) {
 	nodeBytes = nodeBytes[:len(nodeBytes)-minVarIntLen]
 	proofBytesBuf = bytes.NewBuffer(nodeBytes)
 	// Put num children NodeBranchFactor+1 at end
-	err = Codec.(*codecImpl).encodeInt(proofBytesBuf, NodeBranchFactor+1)
-	require.NoError(err)
+	require.NoError(Codec.(*codecImpl).encodeInt(proofBytesBuf, NodeBranchFactor+1))
 
 	_, err = Codec.decodeDBNode(proofBytesBuf.Bytes(), &parsedDBNode)
 	require.ErrorIs(err, errTooManyChildren)
diff --git a/x/merkledb/db_test.go b/x/merkledb/db_test.go
index 4babc62a106f..ec9f6dc16b46 100644
--- a/x/merkledb/db_test.go
+++ b/x/merkledb/db_test.go
@@ -177,12 +177,9 @@ func Test_MerkleDB_Failed_Batch_Commit(t *testing.T) {
 	_ = memDB.Close()
 
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key2"), []byte("2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key3"), []byte("3"))
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key1"), []byte("1")))
+	require.NoError(t, batch.Put([]byte("key2"), []byte("2")))
+	require.NoError(t, batch.Put([]byte("key3"), []byte("3")))
 	err = batch.Write()
 	// batch fails
 	require.ErrorIs(t, err, database.ErrClosed)
@@ -202,22 +199,17 @@ func Test_MerkleDB_Value_Cache(t *testing.T) {
 	require.NoError(t, err)
 
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("1"))
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key1"), []byte("1")))
 
-	err = batch.Put([]byte("key2"), []byte("2"))
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key2"), []byte("2")))
 
 	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Write())
 
 	batch = db.NewBatch()
 	// force key2 to be inserted into the cache as not found
-	err = batch.Delete([]byte("key2"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Delete([]byte("key2")))
+	require.NoError(t, batch.Write())
 
 	_ = memDB.Close()
 
@@ -259,14 +251,10 @@ func Test_MerkleDB_Commit_Proof_To_Empty_Trie(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key2"), []byte("2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key3"), []byte("3"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key1"), []byte("1")))
+	require.NoError(t, batch.Put([]byte("key2"), []byte("2")))
+	require.NoError(t, batch.Put([]byte("key3"), []byte("3")))
+	require.NoError(t, batch.Write())
 
 	proof, err := db.GetRangeProof(context.Background(), []byte("key1"), []byte("key3"), 10)
 	require.NoError(t, err)
@@ -274,8 +262,7 @@ func Test_MerkleDB_Commit_Proof_To_Empty_Trie(t *testing.T) {
 	freshDB, err := getBasicDB()
 	require.NoError(t, err)
 
-	err = freshDB.CommitRangeProof(context.Background(), []byte("key1"), proof)
-	require.NoError(t, err)
+	require.NoError(t, freshDB.CommitRangeProof(context.Background(), []byte("key1"), proof))
 
 	value, err := freshDB.Get([]byte("key2"))
 	require.NoError(t, err)
@@ -292,14 +279,10 @@ func Test_MerkleDB_Commit_Proof_To_Filled_Trie(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key2"), []byte("2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key3"), []byte("3"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key1"), []byte("1")))
+	require.NoError(t, batch.Put([]byte("key2"), []byte("2")))
+	require.NoError(t, batch.Put([]byte("key3"), []byte("3")))
+	require.NoError(t, batch.Write())
 
 	proof, err := db.GetRangeProof(context.Background(), []byte("key1"), []byte("key3"), 10)
 	require.NoError(t, err)
@@ -307,19 +290,13 @@ func Test_MerkleDB_Commit_Proof_To_Filled_Trie(t *testing.T) {
 	freshDB, err := getBasicDB()
 	require.NoError(t, err)
 	batch = freshDB.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("3"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key2"), []byte("4"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key3"), []byte("5"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key25"), []byte("5"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key1"), []byte("3")))
+	require.NoError(t, batch.Put([]byte("key2"), []byte("4")))
+	require.NoError(t, batch.Put([]byte("key3"), []byte("5")))
+	require.NoError(t, batch.Put([]byte("key25"), []byte("5")))
+	require.NoError(t, batch.Write())
 
-	err = freshDB.CommitRangeProof(context.Background(), []byte("key1"), proof)
-	require.NoError(t, err)
+	require.NoError(t, freshDB.CommitRangeProof(context.Background(), []byte("key1"), proof))
 
 	value, err := freshDB.Get([]byte("key2"))
 	require.NoError(t, err)
@@ -359,10 +336,8 @@ func Test_MerkleDB_InsertNil(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key0"), nil)
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key0"), nil))
+	require.NoError(t, batch.Write())
 
 	value, err := db.Get([]byte("key0"))
 	require.NoError(t, err)
@@ -384,8 +359,7 @@ func Test_MerkleDB_InsertAndRetrieve(t *testing.T) {
 	require.ErrorIs(err, database.ErrNotFound)
 	require.Nil(value)
 
-	err = db.Put([]byte("key"), []byte("value"))
-	require.NoError(err)
+	require.NoError(db.Put([]byte("key"), []byte("value")))
 
 	value, err = db.Get([]byte("key"))
 	require.NoError(err)
@@ -404,15 +378,13 @@ func Test_MerkleDB_Overwrite(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 
-	err = db.Put([]byte("key"), []byte("value0"))
-	require.NoError(t, err)
+	require.NoError(t, db.Put([]byte("key"), []byte("value0")))
 
 	value, err := db.Get([]byte("key"))
 	require.NoError(t, err)
 	require.Equal(t, []byte("value0"), value)
 
-	err = db.Put([]byte("key"), []byte("value1"))
-	require.NoError(t, err)
+	require.NoError(t, db.Put([]byte("key"), []byte("value1")))
 
 	value, err = db.Get([]byte("key"))
 	require.NoError(t, err)
@@ -423,15 +395,13 @@ func Test_MerkleDB_Delete(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 
-	err = db.Put([]byte("key"), []byte("value0"))
-	require.NoError(t, err)
+	require.NoError(t, db.Put([]byte("key"), []byte("value0")))
 
 	value, err := db.Get([]byte("key"))
 	require.NoError(t, err)
 	require.Equal(t, []byte("value0"), value)
 
-	err = db.Delete([]byte("key"))
-	require.NoError(t, err)
+	require.NoError(t, db.Delete([]byte("key")))
 
 	value, err = db.Get([]byte("key"))
 	require.ErrorIs(t, err, database.ErrNotFound)
@@ -442,8 +412,7 @@ func Test_MerkleDB_DeleteMissingKey(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 
-	err = db.Delete([]byte("key"))
-	require.NoError(t, err)
+	require.NoError(t, db.Delete([]byte("key")))
 }
 
 // Test that untracked views aren't persisted to [db.childViews].
@@ -459,12 +428,10 @@ func TestDatabaseNewUntrackedView(t *testing.T) {
 	require.Empty(db.childViews)
 
 	// Write to the untracked view.
-	err = view.Insert(context.Background(), []byte{1}, []byte{1})
-	require.NoError(err)
+	require.NoError(view.Insert(context.Background(), []byte{1}, []byte{1}))
 
 	// Commit the view
-	err = view.CommitToDB(context.Background())
-	require.NoError(err)
+	require.NoError(view.CommitToDB(context.Background()))
 
 	// The untracked view should not be tracked by the parent database.
 	require.Empty(db.childViews)
@@ -483,12 +450,10 @@ func TestDatabaseNewPreallocatedViewTracked(t *testing.T) {
 	require.Len(db.childViews, 1)
 
 	// Write to the  view.
-	err = view.Insert(context.Background(), []byte{1}, []byte{1})
-	require.NoError(err)
+	require.NoError(view.Insert(context.Background(), []byte{1}, []byte{1}))
 
 	// Commit the view
-	err = view.CommitToDB(context.Background())
-	require.NoError(err)
+	require.NoError(view.CommitToDB(context.Background()))
 
 	// The untracked view should be tracked by the parent database.
 	require.Contains(db.childViews, view)
@@ -503,8 +468,7 @@ func TestDatabaseCommitChanges(t *testing.T) {
 	dbRoot := db.getMerkleRoot()
 
 	// Committing a nil view should be a no-op.
-	err = db.commitToDB(context.Background())
-	require.NoError(err)
+	require.NoError(db.commitToDB(context.Background()))
 	require.Equal(dbRoot, db.getMerkleRoot()) // Root didn't change
 
 	// Committing an invalid view should fail.
@@ -515,20 +479,16 @@ func TestDatabaseCommitChanges(t *testing.T) {
 	require.ErrorIs(err, ErrInvalid)
 
 	// Add key-value pairs to the database
-	err = db.Put([]byte{1}, []byte{1})
-	require.NoError(err)
-	err = db.Put([]byte{2}, []byte{2})
-	require.NoError(err)
+	require.NoError(db.Put([]byte{1}, []byte{1}))
+	require.NoError(db.Put([]byte{2}, []byte{2}))
 
 	// Make a view and inser/delete a key-value pair.
 	view1Intf, err := db.NewView()
 	require.NoError(err)
 	require.IsType(&trieView{}, view1Intf)
 	view1 := view1Intf.(*trieView)
-	err = view1.Insert(context.Background(), []byte{3}, []byte{3})
-	require.NoError(err)
-	err = view1.Remove(context.Background(), []byte{1})
-	require.NoError(err)
+	require.NoError(view1.Insert(context.Background(), []byte{3}, []byte{3}))
+	require.NoError(view1.Remove(context.Background(), []byte{1}))
 	view1Root, err := view1.getMerkleRoot(context.Background())
 	require.NoError(err)
 
@@ -551,8 +511,7 @@ func TestDatabaseCommitChanges(t *testing.T) {
 	//      db
 
 	// Commit view1
-	err = view1.commitToDB(context.Background())
-	require.NoError(err)
+	require.NoError(view1.commitToDB(context.Background()))
 
 	// Make sure the key-value pairs are correct.
 	_, err = db.Get([]byte{1})
@@ -771,13 +730,11 @@ func runRandDBTest(require *require.Assertions, r *rand.Rand, rt randTest) {
 		require.LessOrEqual(i, len(rt))
 		switch step.op {
 		case opUpdate:
-			err := currentBatch.Put(step.key, step.value)
-			require.NoError(err)
+			require.NoError(currentBatch.Put(step.key, step.value))
 			currentValues[newPath(step.key)] = step.value
 			delete(deleteValues, newPath(step.key))
 		case opDelete:
-			err := currentBatch.Delete(step.key)
-			require.NoError(err)
+			require.NoError(currentBatch.Delete(step.key))
 			deleteValues[newPath(step.key)] = struct{}{}
 			delete(currentValues, newPath(step.key))
 		case opGenerateRangeProof:
@@ -788,13 +745,12 @@ func runRandDBTest(require *require.Assertions, r *rand.Rand, rt randTest) {
 			}
 			rangeProof, err := db.GetRangeProofAtRoot(context.Background(), root, step.key, step.value, 100)
 			require.NoError(err)
-			err = rangeProof.Verify(
+			require.NoError(rangeProof.Verify(
 				context.Background(),
 				step.key,
 				step.value,
 				root,
-			)
-			require.NoError(err)
+			))
 			require.LessOrEqual(len(rangeProof.KeyValues), 100)
 		case opGenerateChangeProof:
 			root, err := db.GetMerkleRoot(context.Background())
@@ -810,20 +766,18 @@ func runRandDBTest(require *require.Assertions, r *rand.Rand, rt randTest) {
 			require.NoError(err)
 			changeProofDB, err := getBasicDB()
 			require.NoError(err)
-			err = changeProofDB.VerifyChangeProof(
+			require.NoError(changeProofDB.VerifyChangeProof(
 				context.Background(),
 				changeProof,
 				step.key,
 				step.value,
 				root,
-			)
-			require.NoError(err)
+			))
 			require.LessOrEqual(len(changeProof.KeyChanges), 100)
 		case opWriteBatch:
 			oldRoot, err := db.GetMerkleRoot(context.Background())
 			require.NoError(err)
-			err = currentBatch.Write()
-			require.NoError(err)
+			require.NoError(currentBatch.Write())
 			for key, value := range currentValues {
 				values[key] = value
 			}
@@ -871,8 +825,7 @@ func runRandDBTest(require *require.Assertions, r *rand.Rand, rt randTest) {
 			require.NoError(err)
 			localTrie := Trie(dbTrie)
 			for key, value := range values {
-				err := localTrie.Insert(context.Background(), key.Serialize().Value, value)
-				require.NoError(err)
+				require.NoError(localTrie.Insert(context.Background(), key.Serialize().Value, value))
 			}
 			calculatedRoot, err := localTrie.GetMerkleRoot(context.Background())
 			require.NoError(err)
diff --git a/x/merkledb/history_test.go b/x/merkledb/history_test.go
index 704dae9bb3c0..951efb3c76cd 100644
--- a/x/merkledb/history_test.go
+++ b/x/merkledb/history_test.go
@@ -28,10 +28,8 @@ func Test_History_Simple(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value")))
+	require.NoError(batch.Write())
 
 	val, err := db.Get([]byte("key"))
 	require.NoError(err)
@@ -41,71 +39,48 @@ func Test_History_Simple(t *testing.T) {
 	require.NoError(err)
 	require.NotNil(origProof)
 	origRootID := db.root.id
-	err = origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value0"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value0")))
+	require.NoError(batch.Write())
 	newProof, err := db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("value1"))
-	require.NoError(err)
-	err = batch.Put([]byte("key8"), []byte("value8"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key1"), []byte("value1")))
+	require.NoError(batch.Put([]byte("key8"), []byte("value8")))
+	require.NoError(batch.Write())
 	newProof, err = db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("k"), []byte("v"))
-	require.NoError(err)
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("k"), []byte("v")))
+	require.NoError(batch.Write())
 	newProof, err = db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	batch = db.NewBatch()
-	err = batch.Delete([]byte("k"))
-	require.NoError(err)
-	err = batch.Delete([]byte("ke"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key1"))
-	require.NoError(err)
-	err = batch.Put([]byte("key2"), []byte("value2"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key3"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key4"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key5"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key8"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Delete([]byte("k")))
+	require.NoError(batch.Delete([]byte("ke")))
+	require.NoError(batch.Delete([]byte("key")))
+	require.NoError(batch.Delete([]byte("key1")))
+	require.NoError(batch.Put([]byte("key2"), []byte("value2")))
+	require.NoError(batch.Delete([]byte("key3")))
+	require.NoError(batch.Delete([]byte("key4")))
+	require.NoError(batch.Delete([]byte("key5")))
+	require.NoError(batch.Delete([]byte("key8")))
+	require.NoError(batch.Write())
 	newProof, err = db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 }
 
 func Test_History_Large(t *testing.T) {
@@ -133,14 +108,12 @@ func Test_History_Large(t *testing.T) {
 			_, err = r.Read(val)
 			require.NoError(err)
 
-			err = db.Put(addkey, val)
-			require.NoError(err)
+			require.NoError(db.Put(addkey, val))
 
 			addNilkey := make([]byte, r.Intn(50))
 			_, err = r.Read(addNilkey)
 			require.NoError(err)
-			err = db.Put(addNilkey, nil)
-			require.NoError(err)
+			require.NoError(db.Put(addNilkey, nil))
 
 			deleteKeyStart := make([]byte, r.Intn(50))
 			_, err = r.Read(deleteKeyStart)
@@ -148,8 +121,7 @@ func Test_History_Large(t *testing.T) {
 
 			it := db.NewIteratorWithStart(deleteKeyStart)
 			if it.Next() {
-				err = db.Delete(it.Key())
-				require.NoError(err)
+				require.NoError(db.Delete(it.Key()))
 			}
 			require.NoError(it.Error())
 			it.Release()
@@ -162,8 +134,7 @@ func Test_History_Large(t *testing.T) {
 		require.NoError(err)
 		require.NotNil(proof)
 
-		err = proof.Verify(context.Background(), nil, nil, roots[0])
-		require.NoError(err)
+		require.NoError(proof.Verify(context.Background(), nil, nil, roots[0]))
 	}
 }
 
@@ -181,38 +152,28 @@ func Test_History_Bad_GetValueChanges_Input(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value")))
+	require.NoError(batch.Write())
 
 	toBeDeletedRoot := db.getMerkleRoot()
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value0"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value0")))
+	require.NoError(batch.Write())
 
 	startRoot := db.getMerkleRoot()
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("value0"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key1"), []byte("value0")))
+	require.NoError(batch.Write())
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("value1"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key1"), []byte("value1")))
+	require.NoError(batch.Write())
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key2"), []byte("value3"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key2"), []byte("value3")))
+	require.NoError(batch.Write())
 
 	endRoot := db.getMerkleRoot()
 
@@ -230,10 +191,8 @@ func Test_History_Bad_GetValueChanges_Input(t *testing.T) {
 
 	// trigger the first root to be deleted by exiting the lookback window
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key2"), []byte("value4"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key2"), []byte("value4")))
+	require.NoError(batch.Write())
 
 	// now this root should no longer be present
 	_, err = db.history.getValueChanges(toBeDeletedRoot, endRoot, nil, nil, 1)
@@ -259,48 +218,40 @@ func Test_History_Trigger_History_Queue_Looping(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value")))
+	require.NoError(batch.Write())
 	origRootID := db.getMerkleRoot()
 
 	origProof, err := db.GetRangeProof(context.Background(), []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(origProof)
-	err = origProof.Verify(
+	require.NoError(origProof.Verify(
 		context.Background(),
 		[]byte("k"),
 		[]byte("key3"),
 		origRootID,
-	)
-	require.NoError(err)
+	))
 
 	// write a new value into the db, now there should be 2 roots in the history
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value0"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value0")))
+	require.NoError(batch.Write())
 
 	// ensure that previous root is still present and generates a valid proof
 	newProof, err := db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(
+	require.NoError(newProof.Verify(
 		context.Background(),
 		[]byte("k"),
 		[]byte("key3"),
 		origRootID,
-	)
-	require.NoError(err)
+	))
 
 	// trigger a new root to be added to the history, which should cause rollover since there can only be 2
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("value1"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key1"), []byte("value1")))
+	require.NoError(batch.Write())
 
 	// proof from first root shouldn't be generatable since it should have been removed from the history
 	_, err = db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
@@ -321,40 +272,30 @@ func Test_History_Values_Lookup_Over_Queue_Break(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value")))
+	require.NoError(batch.Write())
 
 	// write a new value into the db
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value0"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value0")))
+	require.NoError(batch.Write())
 
 	startRoot := db.getMerkleRoot()
 
 	// write a new value into the db
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("value0"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key1"), []byte("value0")))
+	require.NoError(batch.Write())
 
 	// write a new value into the db that overwrites key1
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("value1"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key1"), []byte("value1")))
+	require.NoError(batch.Write())
 
 	// trigger a new root to be added to the history, which should cause rollover since there can only be 3
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key2"), []byte("value3"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key2"), []byte("value3")))
+	require.NoError(batch.Write())
 
 	endRoot := db.getMerkleRoot()
 
@@ -381,53 +322,38 @@ func Test_History_RepeatedRoot(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("value1"))
-	require.NoError(err)
-	err = batch.Put([]byte("key2"), []byte("value2"))
-	require.NoError(err)
-	err = batch.Put([]byte("key3"), []byte("value3"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key1"), []byte("value1")))
+	require.NoError(batch.Put([]byte("key2"), []byte("value2")))
+	require.NoError(batch.Put([]byte("key3"), []byte("value3")))
+	require.NoError(batch.Write())
 
 	origProof, err := db.GetRangeProof(context.Background(), []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(origProof)
 	origRootID := db.root.id
-	err = origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("other"))
-	require.NoError(err)
-	err = batch.Put([]byte("key2"), []byte("other"))
-	require.NoError(err)
-	err = batch.Put([]byte("key3"), []byte("other"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key1"), []byte("other")))
+	require.NoError(batch.Put([]byte("key2"), []byte("other")))
+	require.NoError(batch.Put([]byte("key3"), []byte("other")))
+	require.NoError(batch.Write())
 	newProof, err := db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	// revert state to be the same as in orig proof
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("value1"))
-	require.NoError(err)
-	err = batch.Put([]byte("key2"), []byte("value2"))
-	require.NoError(err)
-	err = batch.Put([]byte("key3"), []byte("value3"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key1"), []byte("value1")))
+	require.NoError(batch.Put([]byte("key2"), []byte("value2")))
+	require.NoError(batch.Put([]byte("key3"), []byte("value3")))
+	require.NoError(batch.Write())
 
 	newProof, err = db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 }
 
 func Test_History_ExcessDeletes(t *testing.T) {
@@ -444,36 +370,26 @@ func Test_History_ExcessDeletes(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value")))
+	require.NoError(batch.Write())
 
 	origProof, err := db.GetRangeProof(context.Background(), []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(origProof)
 	origRootID := db.root.id
-	err = origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	batch = db.NewBatch()
-	err = batch.Delete([]byte("key1"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key2"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key3"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key4"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key5"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Delete([]byte("key1")))
+	require.NoError(batch.Delete([]byte("key2")))
+	require.NoError(batch.Delete([]byte("key3")))
+	require.NoError(batch.Delete([]byte("key4")))
+	require.NoError(batch.Delete([]byte("key5")))
+	require.NoError(batch.Write())
 	newProof, err := db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 }
 
 func Test_History_DontIncludeAllNodes(t *testing.T) {
@@ -490,28 +406,22 @@ func Test_History_DontIncludeAllNodes(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value")))
+	require.NoError(batch.Write())
 
 	origProof, err := db.GetRangeProof(context.Background(), []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(origProof)
 	origRootID := db.root.id
-	err = origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("z"), []byte("z"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("z"), []byte("z")))
+	require.NoError(batch.Write())
 	newProof, err := db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 }
 
 func Test_History_Branching2Nodes(t *testing.T) {
@@ -528,28 +438,22 @@ func Test_History_Branching2Nodes(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value")))
+	require.NoError(batch.Write())
 
 	origProof, err := db.GetRangeProof(context.Background(), []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(origProof)
 	origRootID := db.root.id
-	err = origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("k"), []byte("v"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("k"), []byte("v")))
+	require.NoError(batch.Write())
 	newProof, err := db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 }
 
 func Test_History_Branching3Nodes(t *testing.T) {
@@ -566,28 +470,22 @@ func Test_History_Branching3Nodes(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key123"), []byte("value123"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key123"), []byte("value123")))
+	require.NoError(batch.Write())
 
 	origProof, err := db.GetRangeProof(context.Background(), []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(origProof)
 	origRootID := db.root.id
-	err = origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(origProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key321"), []byte("value321"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key321"), []byte("value321")))
+	require.NoError(batch.Write())
 	newProof, err := db.GetRangeProofAtRoot(context.Background(), origRootID, []byte("k"), []byte("key3"), 10)
 	require.NoError(err)
 	require.NotNil(newProof)
-	err = newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID)
-	require.NoError(err)
+	require.NoError(newProof.Verify(context.Background(), []byte("k"), []byte("key3"), origRootID))
 }
 
 func Test_History_MaxLength(t *testing.T) {
@@ -605,27 +503,21 @@ func Test_History_MaxLength(t *testing.T) {
 	require.NoError(err)
 
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key"), []byte("value"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key"), []byte("value")))
+	require.NoError(batch.Write())
 
 	oldRoot, err := db.GetMerkleRoot(context.Background())
 	require.NoError(err)
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("k"), []byte("v"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("k"), []byte("v")))
+	require.NoError(batch.Write())
 
 	require.Contains(db.history.lastChanges, oldRoot)
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("k1"), []byte("v2"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("k1"), []byte("v2")))
+	require.NoError(batch.Write())
 
 	require.NotContains(db.history.lastChanges, oldRoot)
 }
@@ -644,48 +536,30 @@ func Test_Change_List(t *testing.T) {
 	)
 	require.NoError(err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key20"), []byte("value20"))
-	require.NoError(err)
-	err = batch.Put([]byte("key21"), []byte("value21"))
-	require.NoError(err)
-	err = batch.Put([]byte("key22"), []byte("value22"))
-	require.NoError(err)
-	err = batch.Put([]byte("key23"), []byte("value23"))
-	require.NoError(err)
-	err = batch.Put([]byte("key24"), []byte("value24"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key20"), []byte("value20")))
+	require.NoError(batch.Put([]byte("key21"), []byte("value21")))
+	require.NoError(batch.Put([]byte("key22"), []byte("value22")))
+	require.NoError(batch.Put([]byte("key23"), []byte("value23")))
+	require.NoError(batch.Put([]byte("key24"), []byte("value24")))
+	require.NoError(batch.Write())
 	startRoot, err := db.GetMerkleRoot(context.Background())
 	require.NoError(err)
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key25"), []byte("value25"))
-	require.NoError(err)
-	err = batch.Put([]byte("key26"), []byte("value26"))
-	require.NoError(err)
-	err = batch.Put([]byte("key27"), []byte("value27"))
-	require.NoError(err)
-	err = batch.Put([]byte("key28"), []byte("value28"))
-	require.NoError(err)
-	err = batch.Put([]byte("key29"), []byte("value29"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key25"), []byte("value25")))
+	require.NoError(batch.Put([]byte("key26"), []byte("value26")))
+	require.NoError(batch.Put([]byte("key27"), []byte("value27")))
+	require.NoError(batch.Put([]byte("key28"), []byte("value28")))
+	require.NoError(batch.Put([]byte("key29"), []byte("value29")))
+	require.NoError(batch.Write())
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key30"), []byte("value30"))
-	require.NoError(err)
-	err = batch.Put([]byte("key31"), []byte("value31"))
-	require.NoError(err)
-	err = batch.Put([]byte("key32"), []byte("value32"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key21"))
-	require.NoError(err)
-	err = batch.Delete([]byte("key22"))
-	require.NoError(err)
-	err = batch.Write()
-	require.NoError(err)
+	require.NoError(batch.Put([]byte("key30"), []byte("value30")))
+	require.NoError(batch.Put([]byte("key31"), []byte("value31")))
+	require.NoError(batch.Put([]byte("key32"), []byte("value32")))
+	require.NoError(batch.Delete([]byte("key21")))
+	require.NoError(batch.Delete([]byte("key22")))
+	require.NoError(batch.Write())
 
 	endRoot, err := db.GetMerkleRoot(context.Background())
 	require.NoError(err)
diff --git a/x/merkledb/metrics_test.go b/x/merkledb/metrics_test.go
index be08d7d8fe8b..d66fb6fd3154 100644
--- a/x/merkledb/metrics_test.go
+++ b/x/merkledb/metrics_test.go
@@ -27,15 +27,13 @@ func Test_Metrics_Basic_Usage(t *testing.T) {
 	)
 	require.NoError(t, err)
 
-	err = db.Put([]byte("key"), []byte("value"))
-	require.NoError(t, err)
+	require.NoError(t, db.Put([]byte("key"), []byte("value")))
 
 	require.Equal(t, int64(1), db.metrics.(*mockMetrics).keyReadCount)
 	require.Equal(t, int64(1), db.metrics.(*mockMetrics).keyWriteCount)
 	require.Equal(t, int64(3), db.metrics.(*mockMetrics).hashCount)
 
-	err = db.Delete([]byte("key"))
-	require.NoError(t, err)
+	require.NoError(t, db.Delete([]byte("key")))
 
 	require.Equal(t, int64(1), db.metrics.(*mockMetrics).keyReadCount)
 	require.Equal(t, int64(2), db.metrics.(*mockMetrics).keyWriteCount)
@@ -62,13 +60,11 @@ func Test_Metrics_Initialize(t *testing.T) {
 	)
 	require.NoError(t, err)
 
-	err = db.Put([]byte("key"), []byte("value"))
-	require.NoError(t, err)
+	require.NoError(t, db.Put([]byte("key"), []byte("value")))
 
 	val, err := db.Get([]byte("key"))
 	require.NoError(t, err)
 	require.Equal(t, []byte("value"), val)
 
-	err = db.Delete([]byte("key"))
-	require.NoError(t, err)
+	require.NoError(t, db.Delete([]byte("key")))
 }
diff --git a/x/merkledb/node_test.go b/x/merkledb/node_test.go
index a4282df12f9c..6ace63b36715 100644
--- a/x/merkledb/node_test.go
+++ b/x/merkledb/node_test.go
@@ -19,8 +19,7 @@ func Test_Node_Marshal(t *testing.T) {
 	childNode.setValue(Some([]byte("value")))
 	require.NotNil(t, childNode)
 
-	err := childNode.calculateID(&mockMetrics{})
-	require.NoError(t, err)
+	require.NoError(t, childNode.calculateID(&mockMetrics{}))
 	root.addChild(childNode)
 
 	data, err := root.marshal()
@@ -45,8 +44,7 @@ func Test_Node_Marshal_Errors(t *testing.T) {
 	childNode1.setValue(Some([]byte("value1")))
 	require.NotNil(t, childNode1)
 
-	err := childNode1.calculateID(&mockMetrics{})
-	require.NoError(t, err)
+	require.NoError(t, childNode1.calculateID(&mockMetrics{}))
 	root.addChild(childNode1)
 
 	fullpath = newPath([]byte{237})
@@ -54,8 +52,7 @@ func Test_Node_Marshal_Errors(t *testing.T) {
 	childNode2.setValue(Some([]byte("value2")))
 	require.NotNil(t, childNode2)
 
-	err = childNode2.calculateID(&mockMetrics{})
-	require.NoError(t, err)
+	require.NoError(t, childNode2.calculateID(&mockMetrics{}))
 	root.addChild(childNode2)
 
 	data, err := root.marshal()
diff --git a/x/merkledb/proof_test.go b/x/merkledb/proof_test.go
index 6b6025618090..c65b4940cd82 100644
--- a/x/merkledb/proof_test.go
+++ b/x/merkledb/proof_test.go
@@ -227,13 +227,12 @@ func Test_RangeProof_Extra_Value(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, proof)
 
-	err = proof.Verify(
+	require.NoError(t, proof.Verify(
 		context.Background(),
 		[]byte{1},
 		[]byte{5, 5},
 		db.root.id,
-	)
-	require.NoError(t, err)
+	))
 
 	proof.KeyValues = append(proof.KeyValues, KeyValue{Key: []byte{5}, Value: []byte{5}})
 
@@ -328,16 +327,11 @@ func Test_Proof(t *testing.T) {
 	trie, err := dbTrie.NewView()
 	require.NoError(t, err)
 
-	err = trie.Insert(context.Background(), []byte("key0"), []byte("value0"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key1"), []byte("value1"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key2"), []byte("value2"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key3"), []byte("value3"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key4"), []byte("value4"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key0"), []byte("value0")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key1"), []byte("value1")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key2"), []byte("value2")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key3"), []byte("value3")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key4"), []byte("value4")))
 
 	_, err = trie.GetMerkleRoot(context.Background())
 	require.NoError(t, err)
@@ -355,8 +349,7 @@ func Test_Proof(t *testing.T) {
 
 	expectedRootID, err := trie.GetMerkleRoot(context.Background())
 	require.NoError(t, err)
-	err = proof.Verify(context.Background(), expectedRootID)
-	require.NoError(t, err)
+	require.NoError(t, proof.Verify(context.Background(), expectedRootID))
 
 	proof.Path[0].ValueOrHash = Some([]byte("value2"))
 
@@ -562,13 +555,12 @@ func Test_RangeProof(t *testing.T) {
 	// only a single node here since others are duplicates in endproof
 	require.Equal([]byte{1}, proof.StartProof[0].KeyPath.Value)
 
-	err = proof.Verify(
+	require.NoError(proof.Verify(
 		context.Background(),
 		[]byte{1},
 		[]byte{3, 5},
 		db.root.id,
-	)
-	require.NoError(err)
+	))
 }
 
 func Test_RangeProof_BadBounds(t *testing.T) {
@@ -585,16 +577,11 @@ func Test_RangeProof_NilStart(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key1"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key2"), []byte("value2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key3"), []byte("value3"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key4"), []byte("value4"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key1"), []byte("value1")))
+	require.NoError(t, batch.Put([]byte("key2"), []byte("value2")))
+	require.NoError(t, batch.Put([]byte("key3"), []byte("value3")))
+	require.NoError(t, batch.Put([]byte("key4"), []byte("value4")))
+	require.NoError(t, batch.Write())
 
 	val, err := db.Get([]byte("key1"))
 	require.NoError(t, err)
@@ -616,13 +603,12 @@ func Test_RangeProof_NilStart(t *testing.T) {
 	require.Equal(t, SerializedPath{Value: []uint8{0x6b, 0x65, 0x79, 0x30}, NibbleLength: 7}, proof.EndProof[1].KeyPath)
 	require.Equal(t, newPath([]byte("")).Serialize(), proof.EndProof[0].KeyPath)
 
-	err = proof.Verify(
+	require.NoError(t, proof.Verify(
 		context.Background(),
 		nil,
 		[]byte("key35"),
 		db.root.id,
-	)
-	require.NoError(t, err)
+	))
 }
 
 func Test_RangeProof_NilEnd(t *testing.T) {
@@ -649,27 +635,22 @@ func Test_RangeProof_NilEnd(t *testing.T) {
 	require.Equal(t, []byte{0}, proof.EndProof[1].KeyPath.Value)
 	require.Equal(t, []byte{2}, proof.EndProof[2].KeyPath.Value)
 
-	err = proof.Verify(
+	require.NoError(t, proof.Verify(
 		context.Background(),
 		[]byte{1},
 		nil,
 		db.root.id,
-	)
-	require.NoError(t, err)
+	))
 }
 
 func Test_RangeProof_EmptyValues(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key1"), nil)
-	require.NoError(t, err)
-	err = batch.Put([]byte("key12"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key2"), []byte{})
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key1"), nil))
+	require.NoError(t, batch.Put([]byte("key12"), []byte("value1")))
+	require.NoError(t, batch.Put([]byte("key2"), []byte{}))
+	require.NoError(t, batch.Write())
 
 	val, err := db.Get([]byte("key12"))
 	require.NoError(t, err)
@@ -694,13 +675,12 @@ func Test_RangeProof_EmptyValues(t *testing.T) {
 	require.Equal(t, newPath([]byte("key2")).Serialize(), proof.EndProof[2].KeyPath)
 	require.Equal(t, newPath([]byte{}).Serialize(), proof.EndProof[0].KeyPath)
 
-	err = proof.Verify(
+	require.NoError(t, proof.Verify(
 		context.Background(),
 		[]byte("key1"),
 		[]byte("key2"),
 		db.root.id,
-	)
-	require.NoError(t, err)
+	))
 }
 
 func Test_RangeProof_Marshal_Nil(t *testing.T) {
@@ -786,48 +766,30 @@ func Test_ChangeProof_Marshal(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key0"), []byte("value0"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key1"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key2"), []byte("value2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key3"), []byte("value3"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key4"), []byte("value4"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key0"), []byte("value0")))
+	require.NoError(t, batch.Put([]byte("key1"), []byte("value1")))
+	require.NoError(t, batch.Put([]byte("key2"), []byte("value2")))
+	require.NoError(t, batch.Put([]byte("key3"), []byte("value3")))
+	require.NoError(t, batch.Put([]byte("key4"), []byte("value4")))
+	require.NoError(t, batch.Write())
 	startRoot, err := db.GetMerkleRoot(context.Background())
 	require.NoError(t, err)
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key4"), []byte("value0"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key5"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key6"), []byte("value2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key7"), []byte("value3"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key8"), []byte("value4"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key4"), []byte("value0")))
+	require.NoError(t, batch.Put([]byte("key5"), []byte("value1")))
+	require.NoError(t, batch.Put([]byte("key6"), []byte("value2")))
+	require.NoError(t, batch.Put([]byte("key7"), []byte("value3")))
+	require.NoError(t, batch.Put([]byte("key8"), []byte("value4")))
+	require.NoError(t, batch.Write())
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key9"), []byte("value0"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key10"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key11"), []byte("value2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key12"), []byte("value3"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key13"), []byte("value4"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key9"), []byte("value0")))
+	require.NoError(t, batch.Put([]byte("key10"), []byte("value1")))
+	require.NoError(t, batch.Put([]byte("key11"), []byte("value2")))
+	require.NoError(t, batch.Put([]byte("key12"), []byte("value3")))
+	require.NoError(t, batch.Put([]byte("key13"), []byte("value4")))
+	require.NoError(t, batch.Write())
 	endroot, err := db.GetMerkleRoot(context.Background())
 	require.NoError(t, err)
 
@@ -930,18 +892,12 @@ func Test_ChangeProof_Verify(t *testing.T) {
 	db, err := getBasicDB()
 	require.NoError(t, err)
 	batch := db.NewBatch()
-	err = batch.Put([]byte("key20"), []byte("value0"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key21"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key22"), []byte("value2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key23"), []byte("value3"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key24"), []byte("value4"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key20"), []byte("value0")))
+	require.NoError(t, batch.Put([]byte("key21"), []byte("value1")))
+	require.NoError(t, batch.Put([]byte("key22"), []byte("value2")))
+	require.NoError(t, batch.Put([]byte("key23"), []byte("value3")))
+	require.NoError(t, batch.Put([]byte("key24"), []byte("value4")))
+	require.NoError(t, batch.Write())
 	startRoot, err := db.GetMerkleRoot(context.Background())
 	require.NoError(t, err)
 
@@ -949,53 +905,33 @@ func Test_ChangeProof_Verify(t *testing.T) {
 	dbClone, err := getBasicDB()
 	require.NoError(t, err)
 	batch = dbClone.NewBatch()
-	err = batch.Put([]byte("key20"), []byte("value0"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key21"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key22"), []byte("value2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key23"), []byte("value3"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key24"), []byte("value4"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key20"), []byte("value0")))
+	require.NoError(t, batch.Put([]byte("key21"), []byte("value1")))
+	require.NoError(t, batch.Put([]byte("key22"), []byte("value2")))
+	require.NoError(t, batch.Put([]byte("key23"), []byte("value3")))
+	require.NoError(t, batch.Put([]byte("key24"), []byte("value4")))
+	require.NoError(t, batch.Write())
 
 	// the second db has started to sync some of the range outside of the range proof
 	batch = dbClone.NewBatch()
-	err = batch.Put([]byte("key31"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key31"), []byte("value1")))
+	require.NoError(t, batch.Write())
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key25"), []byte("value0"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key26"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key27"), []byte("value2"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key28"), []byte("value3"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key29"), []byte("value4"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key25"), []byte("value0")))
+	require.NoError(t, batch.Put([]byte("key26"), []byte("value1")))
+	require.NoError(t, batch.Put([]byte("key27"), []byte("value2")))
+	require.NoError(t, batch.Put([]byte("key28"), []byte("value3")))
+	require.NoError(t, batch.Put([]byte("key29"), []byte("value4")))
+	require.NoError(t, batch.Write())
 
 	batch = db.NewBatch()
-	err = batch.Put([]byte("key30"), []byte("value0"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key31"), []byte("value1"))
-	require.NoError(t, err)
-	err = batch.Put([]byte("key32"), []byte("value2"))
-	require.NoError(t, err)
-	err = batch.Delete([]byte("key21"))
-	require.NoError(t, err)
-	err = batch.Delete([]byte("key22"))
-	require.NoError(t, err)
-	err = batch.Write()
-	require.NoError(t, err)
+	require.NoError(t, batch.Put([]byte("key30"), []byte("value0")))
+	require.NoError(t, batch.Put([]byte("key31"), []byte("value1")))
+	require.NoError(t, batch.Put([]byte("key32"), []byte("value2")))
+	require.NoError(t, batch.Delete([]byte("key21")))
+	require.NoError(t, batch.Delete([]byte("key22")))
+	require.NoError(t, batch.Write())
 
 	endRoot, err := db.GetMerkleRoot(context.Background())
 	require.NoError(t, err)
@@ -1005,27 +941,22 @@ func Test_ChangeProof_Verify(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, proof)
 
-	err = dbClone.VerifyChangeProof(context.Background(), proof, []byte("key21"), []byte("key30"), db.getMerkleRoot())
-	require.NoError(t, err)
+	require.NoError(t, dbClone.VerifyChangeProof(context.Background(), proof, []byte("key21"), []byte("key30"), db.getMerkleRoot()))
 
 	// low maxLength
 	proof, err = db.GetChangeProof(context.Background(), startRoot, endRoot, nil, nil, 5)
 	require.NoError(t, err)
 	require.NotNil(t, proof)
 
-	err = dbClone.VerifyChangeProof(context.Background(), proof, nil, nil, db.getMerkleRoot())
-	require.NoError(t, err)
+	require.NoError(t, dbClone.VerifyChangeProof(context.Background(), proof, nil, nil, db.getMerkleRoot()))
 
 	// nil start/end
 	proof, err = db.GetChangeProof(context.Background(), startRoot, endRoot, nil, nil, 50)
 	require.NoError(t, err)
 	require.NotNil(t, proof)
 
-	err = dbClone.VerifyChangeProof(context.Background(), proof, nil, nil, endRoot)
-	require.NoError(t, err)
-
-	err = dbClone.CommitChangeProof(context.Background(), proof)
-	require.NoError(t, err)
+	require.NoError(t, dbClone.VerifyChangeProof(context.Background(), proof, nil, nil, endRoot))
+	require.NoError(t, dbClone.CommitChangeProof(context.Background(), proof))
 
 	newRoot, err := dbClone.GetMerkleRoot(context.Background())
 	require.NoError(t, err)
@@ -1035,8 +966,7 @@ func Test_ChangeProof_Verify(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, proof)
 
-	err = dbClone.VerifyChangeProof(context.Background(), proof, []byte("key20"), []byte("key30"), db.getMerkleRoot())
-	require.NoError(t, err)
+	require.NoError(t, dbClone.VerifyChangeProof(context.Background(), proof, []byte("key20"), []byte("key30"), db.getMerkleRoot()))
 }
 
 func Test_ChangeProof_Verify_Bad_Data(t *testing.T) {
diff --git a/x/merkledb/trie_test.go b/x/merkledb/trie_test.go
index d47b23ecaa8e..0153590f253c 100644
--- a/x/merkledb/trie_test.go
+++ b/x/merkledb/trie_test.go
@@ -121,10 +121,8 @@ func TestTrieViewGetPathTo(t *testing.T) {
 
 	// Insert a key
 	key1 := []byte{0}
-	err = trie.Insert(context.Background(), key1, []byte("value"))
-	require.NoError(err)
-	err = trie.calculateNodeIDs(context.Background())
-	require.NoError(err)
+	require.NoError(trie.Insert(context.Background(), key1, []byte("value")))
+	require.NoError(trie.calculateNodeIDs(context.Background()))
 
 	path, err = trie.getPathTo(newPath(key1))
 	require.NoError(err)
@@ -136,10 +134,8 @@ func TestTrieViewGetPathTo(t *testing.T) {
 
 	// Insert another key which is a child of the first
 	key2 := []byte{0, 1}
-	err = trie.Insert(context.Background(), key2, []byte("value"))
-	require.NoError(err)
-	err = trie.calculateNodeIDs(context.Background())
-	require.NoError(err)
+	require.NoError(trie.Insert(context.Background(), key2, []byte("value")))
+	require.NoError(trie.calculateNodeIDs(context.Background()))
 
 	path, err = trie.getPathTo(newPath(key2))
 	require.NoError(err)
@@ -150,10 +146,8 @@ func TestTrieViewGetPathTo(t *testing.T) {
 
 	// Insert a key which shares no prefix with the others
 	key3 := []byte{255}
-	err = trie.Insert(context.Background(), key3, []byte("value"))
-	require.NoError(err)
-	err = trie.calculateNodeIDs(context.Background())
-	require.NoError(err)
+	require.NoError(trie.Insert(context.Background(), key3, []byte("value")))
+	require.NoError(trie.calculateNodeIDs(context.Background()))
 
 	path, err = trie.getPathTo(newPath(key3))
 	require.NoError(err)
@@ -193,16 +187,14 @@ func Test_Trie_ViewOnCommitedView(t *testing.T) {
 
 	committedTrie, err := dbTrie.NewView()
 	require.NoError(t, err)
-	err = committedTrie.Insert(context.Background(), []byte{0}, []byte{0})
-	require.NoError(t, err)
+	require.NoError(t, committedTrie.Insert(context.Background(), []byte{0}, []byte{0}))
 
 	require.NoError(t, committedTrie.CommitToDB(context.Background()))
 
 	newView, err := committedTrie.NewView()
 	require.NoError(t, err)
 
-	err = newView.Insert(context.Background(), []byte{1}, []byte{1})
-	require.NoError(t, err)
+	require.NoError(t, newView.Insert(context.Background(), []byte{1}, []byte{1}))
 	require.NoError(t, newView.CommitToDB(context.Background()))
 
 	val0, err := dbTrie.GetValue(context.Background(), []byte{0})
@@ -220,26 +212,21 @@ func Test_Trie_Partial_Commit_Leaves_Valid_Tries(t *testing.T) {
 
 	trie2, err := dbTrie.NewView()
 	require.NoError(t, err)
-	err = trie2.Insert(context.Background(), []byte("key"), []byte("value"))
-	require.NoError(t, err)
+	require.NoError(t, trie2.Insert(context.Background(), []byte("key"), []byte("value")))
 
 	trie3, err := trie2.NewView()
 	require.NoError(t, err)
-	err = trie3.Insert(context.Background(), []byte("key1"), []byte("value1"))
-	require.NoError(t, err)
+	require.NoError(t, trie3.Insert(context.Background(), []byte("key1"), []byte("value1")))
 
 	trie4, err := trie3.NewView()
 	require.NoError(t, err)
-	err = trie4.Insert(context.Background(), []byte("key2"), []byte("value2"))
-	require.NoError(t, err)
+	require.NoError(t, trie4.Insert(context.Background(), []byte("key2"), []byte("value2")))
 
 	trie5, err := trie4.NewView()
 	require.NoError(t, err)
-	err = trie5.Insert(context.Background(), []byte("key3"), []byte("value3"))
-	require.NoError(t, err)
+	require.NoError(t, trie5.Insert(context.Background(), []byte("key3"), []byte("value3")))
 
-	err = trie3.CommitToDB(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, trie3.CommitToDB(context.Background()))
 
 	root, err := trie3.GetMerkleRoot(context.Background())
 	require.NoError(t, err)
@@ -265,15 +252,13 @@ func Test_Trie_WriteToDB(t *testing.T) {
 	require.ErrorIs(err, database.ErrNotFound)
 	require.Nil(value)
 
-	err = trie.Insert(context.Background(), []byte("key"), []byte("value"))
-	require.NoError(err)
+	require.NoError(trie.Insert(context.Background(), []byte("key"), []byte("value")))
 
 	value, err = getNodeValue(trie, "key")
 	require.NoError(err)
 	require.Equal([]byte("value"), value)
 
-	err = trie.CommitToDB(context.Background())
-	require.NoError(err)
+	require.NoError(trie.CommitToDB(context.Background()))
 
 	p := newPath([]byte("key"))
 	rawBytes, err := dbTrie.nodeDB.Get(p.Bytes())
@@ -298,8 +283,7 @@ func Test_Trie_InsertAndRetrieve(t *testing.T) {
 	require.ErrorIs(err, database.ErrNotFound)
 	require.Nil(value)
 
-	err = trie.Insert(context.Background(), []byte("key"), []byte("value"))
-	require.NoError(err)
+	require.NoError(trie.Insert(context.Background(), []byte("key"), []byte("value")))
 
 	value, err = getNodeValue(trie, "key")
 	require.NoError(err)
@@ -312,15 +296,13 @@ func Test_Trie_Overwrite(t *testing.T) {
 	require.NotNil(t, dbTrie)
 	trie := Trie(dbTrie)
 
-	err = trie.Insert(context.Background(), []byte("key"), []byte("value0"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key"), []byte("value0")))
 
 	value, err := getNodeValue(trie, "key")
 	require.NoError(t, err)
 	require.Equal(t, []byte("value0"), value)
 
-	err = trie.Insert(context.Background(), []byte("key"), []byte("value1"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key"), []byte("value1")))
 
 	value, err = getNodeValue(trie, "key")
 	require.NoError(t, err)
@@ -333,15 +315,13 @@ func Test_Trie_Delete(t *testing.T) {
 	require.NotNil(t, dbTrie)
 	trie := Trie(dbTrie)
 
-	err = trie.Insert(context.Background(), []byte("key"), []byte("value0"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key"), []byte("value0")))
 
 	value, err := getNodeValue(trie, "key")
 	require.NoError(t, err)
 	require.Equal(t, []byte("value0"), value)
 
-	err = trie.Remove(context.Background(), []byte("key"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Remove(context.Background(), []byte("key")))
 
 	value, err = getNodeValue(trie, "key")
 	require.ErrorIs(t, err, database.ErrNotFound)
@@ -353,8 +333,7 @@ func Test_Trie_DeleteMissingKey(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, trie)
 
-	err = trie.Remove(context.Background(), []byte("key"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Remove(context.Background(), []byte("key")))
 }
 
 func Test_Trie_ExpandOnKeyPath(t *testing.T) {
@@ -363,15 +342,13 @@ func Test_Trie_ExpandOnKeyPath(t *testing.T) {
 	require.NotNil(t, dbTrie)
 	trie := Trie(dbTrie)
 
-	err = trie.Insert(context.Background(), []byte("key"), []byte("value0"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key"), []byte("value0")))
 
 	value, err := getNodeValue(trie, "key")
 	require.NoError(t, err)
 	require.Equal(t, []byte("value0"), value)
 
-	err = trie.Insert(context.Background(), []byte("key1"), []byte("value1"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key1"), []byte("value1")))
 
 	value, err = getNodeValue(trie, "key")
 	require.NoError(t, err)
@@ -381,8 +358,7 @@ func Test_Trie_ExpandOnKeyPath(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, []byte("value1"), value)
 
-	err = trie.Insert(context.Background(), []byte("key12"), []byte("value12"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key12"), []byte("value12")))
 
 	value, err = getNodeValue(trie, "key")
 	require.NoError(t, err)
@@ -403,15 +379,13 @@ func Test_Trie_CompressedPaths(t *testing.T) {
 	require.NotNil(t, dbTrie)
 	trie := Trie(dbTrie)
 
-	err = trie.Insert(context.Background(), []byte("key12"), []byte("value12"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key12"), []byte("value12")))
 
 	value, err := getNodeValue(trie, "key12")
 	require.NoError(t, err)
 	require.Equal(t, []byte("value12"), value)
 
-	err = trie.Insert(context.Background(), []byte("key1"), []byte("value1"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key1"), []byte("value1")))
 
 	value, err = getNodeValue(trie, "key12")
 	require.NoError(t, err)
@@ -421,8 +395,7 @@ func Test_Trie_CompressedPaths(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, []byte("value1"), value)
 
-	err = trie.Insert(context.Background(), []byte("key"), []byte("value"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key"), []byte("value")))
 
 	value, err = getNodeValue(trie, "key12")
 	require.NoError(t, err)
@@ -444,10 +417,8 @@ func Test_Trie_SplitBranch(t *testing.T) {
 	trie := Trie(dbTrie)
 
 	// force a new node to generate with common prefix "key1" and have these two nodes as children
-	err = trie.Insert(context.Background(), []byte("key12"), []byte("value12"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key134"), []byte("value134"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key12"), []byte("value12")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key134"), []byte("value134")))
 
 	value, err := getNodeValue(trie, "key12")
 	require.NoError(t, err)
@@ -465,11 +436,9 @@ func Test_Trie_HashCountOnBranch(t *testing.T) {
 	trie := Trie(dbTrie)
 
 	// force a new node to generate with common prefix "key1" and have these two nodes as children
-	err = trie.Insert(context.Background(), []byte("key12"), []byte("value12"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key12"), []byte("value12")))
 	oldCount := dbTrie.metrics.(*mockMetrics).hashCount
-	err = trie.Insert(context.Background(), []byte("key134"), []byte("value134"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("key134"), []byte("value134")))
 	// only hashes the new branch node, the new child node, and root
 	// shouldn't hash the existing node
 	require.Equal(t, oldCount+3, dbTrie.metrics.(*mockMetrics).hashCount)
@@ -480,30 +449,21 @@ func Test_Trie_HashCountOnDelete(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, trie)
 
-	err = trie.Insert(context.Background(), []byte("k"), []byte("value0"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("ke"), []byte("value1"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key"), []byte("value2"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key1"), []byte("value3"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key2"), []byte("value4"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("k"), []byte("value0")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("ke"), []byte("value1")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key"), []byte("value2")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key1"), []byte("value3")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key2"), []byte("value4")))
 
 	oldCount := trie.metrics.(*mockMetrics).hashCount
 
 	// delete the middle values
 	view, err := trie.NewView()
 	require.NoError(t, err)
-	err = view.Remove(context.Background(), []byte("k"))
-	require.NoError(t, err)
-	err = view.Remove(context.Background(), []byte("ke"))
-	require.NoError(t, err)
-	err = view.Remove(context.Background(), []byte("key"))
-	require.NoError(t, err)
-	err = view.CommitToDB(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, view.Remove(context.Background(), []byte("k")))
+	require.NoError(t, view.Remove(context.Background(), []byte("ke")))
+	require.NoError(t, view.Remove(context.Background(), []byte("key")))
+	require.NoError(t, view.CommitToDB(context.Background()))
 
 	// the root is the only updated node so only one new hash
 	require.Equal(t, oldCount+1, trie.metrics.(*mockMetrics).hashCount)
@@ -515,14 +475,10 @@ func Test_Trie_NoExistingResidual(t *testing.T) {
 	require.NotNil(t, dbTrie)
 	trie := Trie(dbTrie)
 
-	err = trie.Insert(context.Background(), []byte("k"), []byte("1"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("ke"), []byte("2"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key1"), []byte("3"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key123"), []byte("4"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("k"), []byte("1")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("ke"), []byte("2")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key1"), []byte("3")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key123"), []byte("4")))
 
 	value, err := getNodeValue(trie, "k")
 	require.NoError(t, err)
@@ -552,8 +508,7 @@ func Test_Trie_CommitChanges(t *testing.T) {
 	require.IsType(&trieView{}, view1Intf)
 	view1 := view1Intf.(*trieView)
 
-	err = view1.Insert(context.Background(), []byte{1}, []byte{1})
-	require.NoError(err)
+	require.NoError(view1.Insert(context.Background(), []byte{1}, []byte{1}))
 
 	// view1
 	//   |
@@ -568,8 +523,7 @@ func Test_Trie_CommitChanges(t *testing.T) {
 	// Case: Committing a nil view is a no-op
 	oldRoot, err := view1.getMerkleRoot(context.Background())
 	require.NoError(err)
-	err = view1.commitChanges(context.Background(), nil)
-	require.NoError(err)
+	require.NoError(view1.commitChanges(context.Background(), nil))
 	newRoot, err := view1.getMerkleRoot(context.Background())
 	require.NoError(err)
 	require.Equal(oldRoot, newRoot)
@@ -591,10 +545,8 @@ func Test_Trie_CommitChanges(t *testing.T) {
 	require.IsType(&trieView{}, view2Intf)
 	view2 := view2Intf.(*trieView)
 
-	err = view2.Insert(context.Background(), []byte{2}, []byte{2})
-	require.NoError(err)
-	err = view2.Remove(context.Background(), []byte{1})
-	require.NoError(err)
+	require.NoError(view2.Insert(context.Background(), []byte{2}, []byte{2}))
+	require.NoError(view2.Remove(context.Background(), []byte{1}))
 
 	view2Root, err := view2.getMerkleRoot(context.Background())
 	require.NoError(err)
@@ -621,8 +573,7 @@ func Test_Trie_CommitChanges(t *testing.T) {
 	//  db
 
 	// Commit view2 to view1
-	err = view1.commitChanges(context.Background(), view2)
-	require.NoError(err)
+	require.NoError(view1.commitChanges(context.Background(), view2))
 
 	// All siblings of view2 should be invalidated
 	require.True(view3.invalidated)
@@ -676,30 +627,20 @@ func Test_Trie_ChainDeletion(t *testing.T) {
 	newTrie, err := trie.NewView()
 	require.NoError(t, err)
 
-	err = newTrie.Insert(context.Background(), []byte("k"), []byte("value0"))
-	require.NoError(t, err)
-	err = newTrie.Insert(context.Background(), []byte("ke"), []byte("value1"))
-	require.NoError(t, err)
-	err = newTrie.Insert(context.Background(), []byte("key"), []byte("value2"))
-	require.NoError(t, err)
-	err = newTrie.Insert(context.Background(), []byte("key1"), []byte("value3"))
-	require.NoError(t, err)
-	err = newTrie.(*trieView).calculateNodeIDs(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, newTrie.Insert(context.Background(), []byte("k"), []byte("value0")))
+	require.NoError(t, newTrie.Insert(context.Background(), []byte("ke"), []byte("value1")))
+	require.NoError(t, newTrie.Insert(context.Background(), []byte("key"), []byte("value2")))
+	require.NoError(t, newTrie.Insert(context.Background(), []byte("key1"), []byte("value3")))
+	require.NoError(t, newTrie.(*trieView).calculateNodeIDs(context.Background()))
 	root, err := newTrie.getEditableNode(EmptyPath)
 	require.NoError(t, err)
 	require.Len(t, root.children, 1)
 
-	err = newTrie.Remove(context.Background(), []byte("k"))
-	require.NoError(t, err)
-	err = newTrie.Remove(context.Background(), []byte("ke"))
-	require.NoError(t, err)
-	err = newTrie.Remove(context.Background(), []byte("key"))
-	require.NoError(t, err)
-	err = newTrie.Remove(context.Background(), []byte("key1"))
-	require.NoError(t, err)
-	err = newTrie.(*trieView).calculateNodeIDs(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, newTrie.Remove(context.Background(), []byte("k")))
+	require.NoError(t, newTrie.Remove(context.Background(), []byte("ke")))
+	require.NoError(t, newTrie.Remove(context.Background(), []byte("key")))
+	require.NoError(t, newTrie.Remove(context.Background(), []byte("key1")))
+	require.NoError(t, newTrie.(*trieView).calculateNodeIDs(context.Background()))
 	root, err = newTrie.getEditableNode(EmptyPath)
 	require.NoError(t, err)
 	// since all values have been deleted, the nodes should have been cleaned up
@@ -725,8 +666,7 @@ func Test_Trie_Invalidate_Children_On_Edits(t *testing.T) {
 	require.False(t, childTrie2.(*trieView).isInvalid())
 	require.False(t, childTrie3.(*trieView).isInvalid())
 
-	err = trie.Insert(context.Background(), []byte{0}, []byte{0})
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte{0}, []byte{0}))
 
 	require.True(t, childTrie1.(*trieView).isInvalid())
 	require.True(t, childTrie2.(*trieView).isInvalid())
@@ -767,19 +707,13 @@ func Test_Trie_NodeCollapse(t *testing.T) {
 	trie, err := dbTrie.NewView()
 	require.NoError(t, err)
 
-	err = trie.Insert(context.Background(), []byte("k"), []byte("value0"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("ke"), []byte("value1"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key"), []byte("value2"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key1"), []byte("value3"))
-	require.NoError(t, err)
-	err = trie.Insert(context.Background(), []byte("key2"), []byte("value4"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Insert(context.Background(), []byte("k"), []byte("value0")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("ke"), []byte("value1")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key"), []byte("value2")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key1"), []byte("value3")))
+	require.NoError(t, trie.Insert(context.Background(), []byte("key2"), []byte("value4")))
 
-	err = trie.(*trieView).calculateNodeIDs(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, trie.(*trieView).calculateNodeIDs(context.Background()))
 	root, err := trie.getEditableNode(EmptyPath)
 	require.NoError(t, err)
 	require.Len(t, root.children, 1)
@@ -793,15 +727,11 @@ func Test_Trie_NodeCollapse(t *testing.T) {
 	require.Len(t, firstNode.children, 1)
 
 	// delete the middle values
-	err = trie.Remove(context.Background(), []byte("k"))
-	require.NoError(t, err)
-	err = trie.Remove(context.Background(), []byte("ke"))
-	require.NoError(t, err)
-	err = trie.Remove(context.Background(), []byte("key"))
-	require.NoError(t, err)
+	require.NoError(t, trie.Remove(context.Background(), []byte("k")))
+	require.NoError(t, trie.Remove(context.Background(), []byte("ke")))
+	require.NoError(t, trie.Remove(context.Background(), []byte("key")))
 
-	err = trie.(*trieView).calculateNodeIDs(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, trie.(*trieView).calculateNodeIDs(context.Background()))
 
 	root, err = trie.getEditableNode(EmptyPath)
 	require.NoError(t, err)
@@ -925,12 +855,10 @@ func TestNewViewOnCommittedView(t *testing.T) {
 	require.Contains(db.childViews, view1)
 	require.Equal(db, view1.parentTrie)
 
-	err = view1.Insert(context.Background(), []byte{1}, []byte{1})
-	require.NoError(err)
+	require.NoError(view1.Insert(context.Background(), []byte{1}, []byte{1}))
 
 	// Commit the view
-	err = view1.CommitToDB(context.Background())
-	require.NoError(err)
+	require.NoError(view1.CommitToDB(context.Background()))
 
 	// view1 (committed)
 	//   |
@@ -984,8 +912,7 @@ func TestNewViewOnCommittedView(t *testing.T) {
 	require.Len(db.childViews, 2)
 
 	// Commit view2
-	err = view2.CommitToDB(context.Background())
-	require.NoError(err)
+	require.NoError(view2.CommitToDB(context.Background()))
 
 	// view3
 	//   |
@@ -1003,8 +930,7 @@ func TestNewViewOnCommittedView(t *testing.T) {
 	require.Equal(db, view3.parentTrie)
 
 	// Commit view3
-	err = view3.CommitToDB(context.Background())
-	require.NoError(err)
+	require.NoError(view3.CommitToDB(context.Background()))
 
 	// view3 being committed invalidates view2
 	require.True(view2.invalidated)
@@ -1043,8 +969,7 @@ func Test_TrieView_NewView(t *testing.T) {
 	require.Len(view1.childViews, 1)
 
 	// Commit view1
-	err = view1.CommitToDB(context.Background())
-	require.NoError(err)
+	require.NoError(view1.CommitToDB(context.Background()))
 
 	// Make another view atop view1
 	view3Intf, err := view1.NewView()
@@ -1196,18 +1121,15 @@ func Test_Trie_CommitToParentView_Concurrent(t *testing.T) {
 
 		parentView, err := baseView.NewView()
 		require.NoError(t, err)
-		err = parentView.Insert(context.Background(), []byte{0}, []byte{0})
-		require.NoError(t, err)
+		require.NoError(t, parentView.Insert(context.Background(), []byte{0}, []byte{0}))
 
 		childView1, err := parentView.NewView()
 		require.NoError(t, err)
-		err = childView1.Insert(context.Background(), []byte{1}, []byte{1})
-		require.NoError(t, err)
+		require.NoError(t, childView1.Insert(context.Background(), []byte{1}, []byte{1}))
 
 		childView2, err := childView1.NewView()
 		require.NoError(t, err)
-		err = childView2.Insert(context.Background(), []byte{2}, []byte{2})
-		require.NoError(t, err)
+		require.NoError(t, childView2.Insert(context.Background(), []byte{2}, []byte{2}))
 
 		var wg sync.WaitGroup
 		wg.Add(3)
@@ -1248,18 +1170,15 @@ func Test_Trie_CommitToParentDB_Concurrent(t *testing.T) {
 
 		parentView, err := dbTrie.NewView()
 		require.NoError(t, err)
-		err = parentView.Insert(context.Background(), []byte{0}, []byte{0})
-		require.NoError(t, err)
+		require.NoError(t, parentView.Insert(context.Background(), []byte{0}, []byte{0}))
 
 		childView1, err := parentView.NewView()
 		require.NoError(t, err)
-		err = childView1.Insert(context.Background(), []byte{1}, []byte{1})
-		require.NoError(t, err)
+		require.NoError(t, childView1.Insert(context.Background(), []byte{1}, []byte{1}))
 
 		childView2, err := childView1.NewView()
 		require.NoError(t, err)
-		err = childView2.Insert(context.Background(), []byte{2}, []byte{2})
-		require.NoError(t, err)
+		require.NoError(t, childView2.Insert(context.Background(), []byte{2}, []byte{2}))
 
 		var wg sync.WaitGroup
 		wg.Add(3)
@@ -1307,8 +1226,7 @@ func Test_Trie_ConcurrentReadWrite(t *testing.T) {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		err := newTrie.Insert(context.Background(), []byte("key"), []byte("value"))
-		require.NoError(err)
+		require.NoError(newTrie.Insert(context.Background(), []byte("key"), []byte("value")))
 	}()
 
 	require.Eventually(
@@ -1337,8 +1255,7 @@ func Test_Trie_ConcurrentNewViewAndCommit(t *testing.T) {
 
 	newTrie, err := trie.NewView()
 	require.NoError(err)
-	err = newTrie.Insert(context.Background(), []byte("key"), []byte("value0"))
-	require.NoError(err)
+	require.NoError(newTrie.Insert(context.Background(), []byte("key"), []byte("value0")))
 
 	var wg sync.WaitGroup
 	defer wg.Wait()
@@ -1346,8 +1263,7 @@ func Test_Trie_ConcurrentNewViewAndCommit(t *testing.T) {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		err := newTrie.CommitToDB(context.Background())
-		require.NoError(err)
+		require.NoError(newTrie.CommitToDB(context.Background()))
 	}()
 
 	newView, err := newTrie.NewView()
@@ -1364,8 +1280,7 @@ func Test_Trie_ConcurrentDeleteAndMerkleRoot(t *testing.T) {
 
 	newTrie, err := trie.NewView()
 	require.NoError(err)
-	err = newTrie.Insert(context.Background(), []byte("key"), []byte("value0"))
-	require.NoError(err)
+	require.NoError(newTrie.Insert(context.Background(), []byte("key"), []byte("value0")))
 
 	var wg sync.WaitGroup
 	defer wg.Wait()
@@ -1373,8 +1288,7 @@ func Test_Trie_ConcurrentDeleteAndMerkleRoot(t *testing.T) {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		err := newTrie.Remove(context.Background(), []byte("key"))
-		require.NoError(err)
+		require.NoError(newTrie.Remove(context.Background(), []byte("key")))
 	}()
 
 	rootID, err := newTrie.GetMerkleRoot(context.Background())
@@ -1398,8 +1312,7 @@ func Test_Trie_ConcurrentInsertProveCommit(t *testing.T) {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		err := newTrie.Insert(context.Background(), []byte("key2"), []byte("value2"))
-		require.NoError(err)
+		require.NoError(newTrie.Insert(context.Background(), []byte("key2"), []byte("value2")))
 	}()
 
 	require.Eventually(
@@ -1415,8 +1328,7 @@ func Test_Trie_ConcurrentInsertProveCommit(t *testing.T) {
 			}
 			require.Equal([]byte("value2"), proof.Value.value)
 
-			err = newTrie.CommitToDB(context.Background())
-			require.NoError(err)
+			require.NoError(newTrie.CommitToDB(context.Background()))
 			return true
 		},
 		time.Second,
@@ -1433,8 +1345,7 @@ func Test_Trie_ConcurrentInsertAndRangeProof(t *testing.T) {
 
 	newTrie, err := trie.NewView()
 	require.NoError(err)
-	err = newTrie.Insert(context.Background(), []byte("key1"), []byte("value1"))
-	require.NoError(err)
+	require.NoError(newTrie.Insert(context.Background(), []byte("key1"), []byte("value1")))
 
 	var wg sync.WaitGroup
 	defer wg.Wait()
@@ -1442,10 +1353,8 @@ func Test_Trie_ConcurrentInsertAndRangeProof(t *testing.T) {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		err := newTrie.Insert(context.Background(), []byte("key2"), []byte("value2"))
-		require.NoError(err)
-		err = newTrie.Insert(context.Background(), []byte("key3"), []byte("value3"))
-		require.NoError(err)
+		require.NoError(newTrie.Insert(context.Background(), []byte("key2"), []byte("value2")))
+		require.NoError(newTrie.Insert(context.Background(), []byte("key3"), []byte("value3")))
 	}()
 
 	require.Eventually(
diff --git a/x/sync/client_test.go b/x/sync/client_test.go
index b8a6561e5361..4f5087745006 100644
--- a/x/sync/client_test.go
+++ b/x/sync/client_test.go
@@ -45,8 +45,7 @@ func sendRangeRequest(
 	handler := NewNetworkServer(sender, db, logging.NoLog{})
 	clientNodeID, serverNodeID := ids.GenerateTestNodeID(), ids.GenerateTestNodeID()
 	networkClient := NewNetworkClient(sender, clientNodeID, 1, logging.NoLog{})
-	err := networkClient.Connected(context.Background(), serverNodeID, version.CurrentApp)
-	require.NoError(err)
+	require.NoError(networkClient.Connected(context.Background(), serverNodeID, version.CurrentApp))
 	client := NewClient(&ClientConfig{
 		NetworkClient: networkClient,
 		Metrics:       &mockMetrics{},
@@ -75,8 +74,7 @@ func sendRangeRequest(
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				err := handler.AppRequest(ctx, clientNodeID, requestID, deadline, requestBytes)
-				require.NoError(err)
+				require.NoError(handler.AppRequest(ctx, clientNodeID, requestID, deadline, requestBytes))
 			}() // should be on a goroutine so the test can make progress.
 			return nil
 		},
@@ -101,8 +99,7 @@ func sendRangeRequest(
 			// reserialize the response and pass it to the client to complete the handling.
 			responseBytes, err = merkledb.Codec.EncodeRangeProof(merkledb.Version, response)
 			require.NoError(err)
-			err = networkClient.AppResponse(context.Background(), serverNodeID, requestID, responseBytes)
-			require.NoError(err)
+			require.NoError(networkClient.AppResponse(context.Background(), serverNodeID, requestID, responseBytes))
 			return nil
 		},
 	).AnyTimes()
@@ -301,8 +298,7 @@ func sendChangeRequest(
 	handler := NewNetworkServer(sender, db, logging.NoLog{})
 	clientNodeID, serverNodeID := ids.GenerateTestNodeID(), ids.GenerateTestNodeID()
 	networkClient := NewNetworkClient(sender, clientNodeID, 1, logging.NoLog{})
-	err := networkClient.Connected(context.Background(), serverNodeID, version.CurrentApp)
-	require.NoError(err)
+	require.NoError(networkClient.Connected(context.Background(), serverNodeID, version.CurrentApp))
 	client := NewClient(&ClientConfig{
 		NetworkClient: networkClient,
 		Metrics:       &mockMetrics{},
@@ -331,8 +327,7 @@ func sendChangeRequest(
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				err := handler.AppRequest(ctx, clientNodeID, requestID, deadline, requestBytes)
-				require.NoError(err)
+				require.NoError(handler.AppRequest(ctx, clientNodeID, requestID, deadline, requestBytes))
 			}() // should be on a goroutine so the test can make progress.
 			return nil
 		},
@@ -357,8 +352,7 @@ func sendChangeRequest(
 			// reserialize the response and pass it to the client to complete the handling.
 			responseBytes, err = merkledb.Codec.EncodeChangeProof(merkledb.Version, response)
 			require.NoError(err)
-			err = networkClient.AppResponse(context.Background(), serverNodeID, requestID, responseBytes)
-			require.NoError(err)
+			require.NoError(networkClient.AppResponse(context.Background(), serverNodeID, requestID, responseBytes))
 			return nil
 		},
 	).AnyTimes()
@@ -407,8 +401,7 @@ func TestGetChangeProof(t *testing.T) {
 			_, err = r.Read(val)
 			require.NoError(t, err)
 
-			err = view.Insert(context.Background(), key, val)
-			require.NoError(t, err)
+			require.NoError(t, view.Insert(context.Background(), key, val))
 		}
 
 		// delete a key
@@ -418,8 +411,7 @@ func TestGetChangeProof(t *testing.T) {
 
 		it := trieDB.NewIteratorWithStart(deleteKeyStart)
 		if it.Next() {
-			err = view.Remove(context.Background(), it.Key())
-			require.NoError(t, err)
+			require.NoError(t, view.Remove(context.Background(), it.Key()))
 		}
 		require.NoError(t, it.Error())
 		it.Release()
diff --git a/x/sync/network_server_test.go b/x/sync/network_server_test.go
index 9bc0dbb2d042..b76bcd70f7fa 100644
--- a/x/sync/network_server_test.go
+++ b/x/sync/network_server_test.go
@@ -160,8 +160,7 @@ func Test_Server_GetChangeProof(t *testing.T) {
 		_, err = r.Read(val)
 		require.NoError(t, err)
 
-		err = view.Insert(context.Background(), key, val)
-		require.NoError(t, err)
+		require.NoError(t, view.Insert(context.Background(), key, val))
 
 		deleteKeyStart := make([]byte, r.Intn(10))
 		_, err = r.Read(deleteKeyStart)
@@ -169,8 +168,7 @@ func Test_Server_GetChangeProof(t *testing.T) {
 
 		it := trieDB.NewIteratorWithStart(deleteKeyStart)
 		if it.Next() {
-			err = view.Remove(context.Background(), it.Key())
-			require.NoError(t, err)
+			require.NoError(t, view.Remove(context.Background(), it.Key()))
 		}
 		require.NoError(t, it.Error())
 		it.Release()
diff --git a/x/sync/sync_test.go b/x/sync/sync_test.go
index 6421551ad5b9..d62938e16bc2 100644
--- a/x/sync/sync_test.go
+++ b/x/sync/sync_test.go
@@ -115,10 +115,8 @@ func Test_Completion(t *testing.T) {
 		})
 		require.NoError(t, err)
 		require.NotNil(t, syncer)
-		err = syncer.StartSyncing(context.Background())
-		require.NoError(t, err)
-		err = syncer.Wait(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, syncer.StartSyncing(context.Background()))
+		require.NoError(t, syncer.Wait(context.Background()))
 		syncer.workLock.Lock()
 		require.Zero(t, syncer.unprocessedWork.Len())
 		require.Equal(t, 1, syncer.processedWork.Len())
@@ -217,10 +215,8 @@ func Test_Sync_FindNextKey_InSync(t *testing.T) {
 		require.NoError(t, err)
 		require.NotNil(t, syncer)
 
-		err = syncer.StartSyncing(context.Background())
-		require.NoError(t, err)
-		err = syncer.Wait(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, syncer.StartSyncing(context.Background()))
+		require.NoError(t, syncer.Wait(context.Background()))
 
 		proof, err := dbToSync.GetRangeProof(context.Background(), nil, nil, 500)
 		require.NoError(t, err)
@@ -233,8 +229,7 @@ func Test_Sync_FindNextKey_InSync(t *testing.T) {
 
 		// add an extra value to sync db past the last key returned
 		newKey := midPoint(lastKey, nil)
-		err = db.Put(newKey, []byte{1})
-		require.NoError(t, err)
+		require.NoError(t, db.Put(newKey, []byte{1}))
 
 		// create a range endpoint that is before the newly added key, but after the last key
 		endPointBeforeNewKey := make([]byte, 0, 2)
@@ -411,10 +406,8 @@ func Test_Sync_FindNextKey_ExtraValues(t *testing.T) {
 		require.NoError(t, err)
 		require.NotNil(t, syncer)
 
-		err = syncer.StartSyncing(context.Background())
-		require.NoError(t, err)
-		err = syncer.Wait(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, syncer.StartSyncing(context.Background()))
+		require.NoError(t, syncer.Wait(context.Background()))
 
 		proof, err := dbToSync.GetRangeProof(context.Background(), nil, nil, 500)
 		require.NoError(t, err)
@@ -423,8 +416,7 @@ func Test_Sync_FindNextKey_ExtraValues(t *testing.T) {
 		lastKey := proof.KeyValues[len(proof.KeyValues)-1].Key
 		midpoint := midPoint(lastKey, nil)
 
-		err = db.Put(midpoint, []byte{1})
-		require.NoError(t, err)
+		require.NoError(t, db.Put(midpoint, []byte{1}))
 
 		// next key at prefix of newly added point
 		nextKey, err := syncer.findNextKey(context.Background(), lastKey, nil, proof.EndProof)
@@ -433,11 +425,9 @@ func Test_Sync_FindNextKey_ExtraValues(t *testing.T) {
 
 		require.True(t, isPrefix(midpoint, nextKey))
 
-		err = db.Delete(midpoint)
-		require.NoError(t, err)
+		require.NoError(t, db.Delete(midpoint))
 
-		err = dbToSync.Put(midpoint, []byte{1})
-		require.NoError(t, err)
+		require.NoError(t, dbToSync.Put(midpoint, []byte{1}))
 
 		proof, err = dbToSync.GetRangeProof(context.Background(), nil, lastKey, 500)
 		require.NoError(t, err)
@@ -492,10 +482,8 @@ func Test_Sync_FindNextKey_DifferentChild(t *testing.T) {
 		})
 		require.NoError(t, err)
 		require.NotNil(t, syncer)
-		err = syncer.StartSyncing(context.Background())
-		require.NoError(t, err)
-		err = syncer.Wait(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, syncer.StartSyncing(context.Background()))
+		require.NoError(t, syncer.Wait(context.Background()))
 
 		proof, err := dbToSync.GetRangeProof(context.Background(), nil, nil, 100)
 		require.NoError(t, err)
@@ -503,11 +491,9 @@ func Test_Sync_FindNextKey_DifferentChild(t *testing.T) {
 
 		// local db has a different child than remote db
 		lastKey = append(lastKey, 16)
-		err = db.Put(lastKey, []byte{1})
-		require.NoError(t, err)
+		require.NoError(t, db.Put(lastKey, []byte{1}))
 
-		err = dbToSync.Put(lastKey, []byte{2})
-		require.NoError(t, err)
+		require.NoError(t, dbToSync.Put(lastKey, []byte{2}))
 
 		proof, err = dbToSync.GetRangeProof(context.Background(), nil, proof.KeyValues[len(proof.KeyValues)-1].Key, 100)
 		require.NoError(t, err)
@@ -563,8 +549,7 @@ func TestFindNextKeyRandom(t *testing.T) {
 			key := make([]byte, rand.Intn(maxKeyLen))
 			_, _ = rand.Read(key)
 			val := make([]byte, rand.Intn(maxValLen))
-			err := db.Put(key, val)
-			require.NoError(err)
+			require.NoError(db.Put(key, val))
 		}
 	}
 
@@ -598,12 +583,11 @@ func TestFindNextKeyRandom(t *testing.T) {
 
 		// Commit the proof to the local database as we do
 		// in the actual syncer.
-		err = localDB.CommitRangeProof(
+		require.NoError(localDB.CommitRangeProof(
 			context.Background(),
 			rangeStart,
 			remoteProof,
-		)
-		require.NoError(err)
+		))
 
 		localProof, err := localDB.GetProof(
 			context.Background(),
@@ -761,11 +745,9 @@ func Test_Sync_Result_Correct_Root(t *testing.T) {
 		})
 		require.NoError(t, err)
 		require.NotNil(t, syncer)
-		err = syncer.StartSyncing(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, syncer.StartSyncing(context.Background()))
 
-		err = syncer.Wait(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, syncer.Wait(context.Background()))
 		require.NoError(t, syncer.Error())
 
 		// new db has fully sync'ed and should be at the same root as the original db
@@ -781,11 +763,9 @@ func Test_Sync_Result_Correct_Root(t *testing.T) {
 		_, err = r.Read(val)
 		require.NoError(t, err)
 
-		err = db.Put(addkey, val)
-		require.NoError(t, err)
+		require.NoError(t, db.Put(addkey, val))
 
-		err = dbToSync.Put(addkey, val)
-		require.NoError(t, err)
+		require.NoError(t, dbToSync.Put(addkey, val))
 
 		syncRoot, err = dbToSync.GetMerkleRoot(context.Background())
 		require.NoError(t, err)
@@ -824,8 +804,7 @@ func Test_Sync_Result_Correct_Root_With_Sync_Restart(t *testing.T) {
 		})
 		require.NoError(t, err)
 		require.NotNil(t, syncer)
-		err = syncer.StartSyncing(context.Background())
-		require.NoError(t, err)
+		require.NoError(t, syncer.StartSyncing(context.Background()))
 
 		// Wait until we've processed some work
 		// before updating the sync target.
@@ -911,8 +890,7 @@ func Test_Sync_Error_During_Sync(t *testing.T) {
 	require.NoError(err)
 	require.NotNil(t, syncer)
 
-	err = syncer.StartSyncing(context.Background())
-	require.NoError(err)
+	require.NoError(syncer.StartSyncing(context.Background()))
 
 	err = syncer.Wait(context.Background())
 	require.ErrorIs(err, errInvalidRangeProof)
@@ -941,8 +919,7 @@ func Test_Sync_Result_Correct_Root_Update_Root_During(t *testing.T) {
 			_, err = r.Read(val)
 			require.NoError(err)
 
-			err = dbToSync.Put(key, val)
-			require.NoError(err)
+			require.NoError(dbToSync.Put(key, val))
 
 			deleteKeyStart := make([]byte, r.Intn(50))
 			_, err = r.Read(deleteKeyStart)
@@ -950,8 +927,7 @@ func Test_Sync_Result_Correct_Root_Update_Root_During(t *testing.T) {
 
 			it := dbToSync.NewIteratorWithStart(deleteKeyStart)
 			if it.Next() {
-				err = dbToSync.Delete(it.Key())
-				require.NoError(err)
+				require.NoError(dbToSync.Delete(it.Key()))
 			}
 			require.NoError(it.Error())
 			it.Release()
@@ -1005,8 +981,7 @@ func Test_Sync_Result_Correct_Root_Update_Root_During(t *testing.T) {
 		require.NoError(err)
 		require.NotNil(t, syncer)
 
-		err = syncer.StartSyncing(context.Background())
-		require.NoError(err)
+		require.NoError(syncer.StartSyncing(context.Background()))
 
 		// Wait until we've processed some work
 		// before updating the sync target.
@@ -1070,8 +1045,7 @@ func Test_Sync_UpdateSyncTarget(t *testing.T) {
 
 	<-startedWaiting
 	newSyncRoot := ids.GenerateTestID()
-	err = m.UpdateSyncTarget(newSyncRoot)
-	require.NoError(err)
+	require.NoError(m.UpdateSyncTarget(newSyncRoot))
 	<-gotSignalChan
 
 	require.Equal(newSyncRoot, m.config.TargetRoot)