Merge branch 'main' into marko/lazy-aggregation-adr

tac0turtle · web-flow · commit 86150790deec · 2025-05-02T17:09:00.000+02:00
diff --git a/block/publish_block_test.go b/block/publish_block_test.go
@@ -328,8 +328,6 @@ func Test_publishBlock_EmptyBatch(t *testing.T) {
 // is successfully created, applied, and published.
 func Test_publishBlock_Success(t *testing.T) {
 	require := require.New(t)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
 
 	initialHeight := uint64(5)
 	newHeight := initialHeight + 1
@@ -338,25 +336,25 @@ func Test_publishBlock_Success(t *testing.T) {
 	manager, mockStore, mockExec, mockSeq, _, headerCh, dataCh, _ := setupManagerForPublishBlockTest(t, true, initialHeight, 0)
 	manager.lastState.LastBlockHeight = initialHeight
 
-	mockStore.On("Height", ctx).Return(initialHeight, nil).Once()
+	mockStore.On("Height", t.Context()).Return(initialHeight, nil).Once()
 	mockSignature := types.Signature([]byte{1, 2, 3})
-	mockStore.On("GetSignature", ctx, initialHeight).Return(&mockSignature, nil).Once()
+	mockStore.On("GetSignature", t.Context(), initialHeight).Return(&mockSignature, nil).Once()
 	lastHeader, lastData := types.GetRandomBlock(initialHeight, 5, chainID)
 	lastHeader.ProposerAddress = manager.genesis.ProposerAddress
-	mockStore.On("GetBlockData", ctx, initialHeight).Return(lastHeader, lastData, nil).Once()
-	mockStore.On("GetBlockData", ctx, newHeight).Return(nil, nil, errors.New("not found")).Once()
-	mockStore.On("SaveBlockData", ctx, mock.AnythingOfType("*types.SignedHeader"), mock.AnythingOfType("*types.Data"), mock.AnythingOfType("*types.Signature")).Return(nil).Once()
-	mockStore.On("SaveBlockData", ctx, mock.AnythingOfType("*types.SignedHeader"), mock.AnythingOfType("*types.Data"), mock.AnythingOfType("*types.Signature")).Return(nil).Once()
-	mockStore.On("SetHeight", ctx, newHeight).Return(nil).Once()
-	mockStore.On("UpdateState", ctx, mock.AnythingOfType("types.State")).Return(nil).Once()
-	mockStore.On("SetMetadata", ctx, LastBatchDataKey, mock.AnythingOfType("[]uint8")).Return(nil).Once()
+	mockStore.On("GetBlockData", t.Context(), initialHeight).Return(lastHeader, lastData, nil).Once()
+	mockStore.On("GetBlockData", t.Context(), newHeight).Return(nil, nil, errors.New("not found")).Once()
+	mockStore.On("SaveBlockData", t.Context(), mock.AnythingOfType("*types.SignedHeader"), mock.AnythingOfType("*types.Data"), mock.AnythingOfType("*types.Signature")).Return(nil).Once()
+	mockStore.On("SaveBlockData", t.Context(), mock.AnythingOfType("*types.SignedHeader"), mock.AnythingOfType("*types.Data"), mock.AnythingOfType("*types.Signature")).Return(nil).Once()
+	mockStore.On("SetHeight", t.Context(), newHeight).Return(nil).Once()
+	mockStore.On("UpdateState", t.Context(), mock.AnythingOfType("types.State")).Return(nil).Once()
+	mockStore.On("SetMetadata", t.Context(), LastBatchDataKey, mock.AnythingOfType("[]uint8")).Return(nil).Once()
 
 	// --- Mock Executor ---
 	sampleTxs := [][]byte{[]byte("tx1"), []byte("tx2")}
 	// No longer mocking GetTxs since it's handled by reaper.go
 	newAppHash := []byte("newAppHash")
-	mockExec.On("ExecuteTxs", ctx, mock.Anything, newHeight, mock.AnythingOfType("time.Time"), manager.lastState.AppHash).Return(newAppHash, uint64(100), nil).Once()
-	mockExec.On("SetFinal", ctx, newHeight).Return(nil).Once()
+	mockExec.On("ExecuteTxs", t.Context(), mock.Anything, newHeight, mock.AnythingOfType("time.Time"), manager.lastState.AppHash).Return(newAppHash, uint64(100), nil).Once()
+	mockExec.On("SetFinal", t.Context(), newHeight).Return(nil).Once()
 
 	// No longer mocking SubmitRollupBatchTxs since it's handled by reaper.go
 	batchTimestamp := lastHeader.Time().Add(1 * time.Second)
@@ -371,8 +369,8 @@ func Test_publishBlock_Success(t *testing.T) {
 	batchReqMatcher := mock.MatchedBy(func(req coresequencer.GetNextBatchRequest) bool {
 		return string(req.RollupId) == chainID
 	})
-	mockSeq.On("GetNextBatch", ctx, batchReqMatcher).Return(batchResponse, nil).Once()
-	err := manager.publishBlock(ctx)
+	mockSeq.On("GetNextBatch", t.Context(), batchReqMatcher).Return(batchResponse, nil).Once()
+	err := manager.publishBlock(t.Context())
 	require.NoError(err, "publishBlock should succeed")
 
 	select {
diff --git a/block/reaper_test.go b/block/reaper_test.go
@@ -1,7 +1,6 @@
 package block
 
 import (
-	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"testing"
@@ -18,8 +17,6 @@ import (
 )
 
 func TestReaper_SubmitTxs_Success(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
 
 	mockExec := testmocks.NewExecutor(t)
 	mockSeq := testmocks.NewSequencer(t)
@@ -28,7 +25,7 @@ func TestReaper_SubmitTxs_Success(t *testing.T) {
 	chainID := "test-chain"
 	interval := 100 * time.Millisecond
 
-	reaper := NewReaper(ctx, mockExec, mockSeq, chainID, interval, logger, store)
+	reaper := NewReaper(t.Context(), mockExec, mockSeq, chainID, interval, logger, store)
 
 	// Prepare transaction and its hash
 	tx := []byte("tx1")
@@ -55,8 +52,6 @@ func TestReaper_SubmitTxs_Success(t *testing.T) {
 }
 
 func TestReaper_SubmitTxs_NoTxs(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
 
 	mockExec := testmocks.NewExecutor(t)
 	mockSeq := testmocks.NewSequencer(t)
@@ -65,7 +60,7 @@ func TestReaper_SubmitTxs_NoTxs(t *testing.T) {
 	chainID := "test-chain"
 	interval := 100 * time.Millisecond
 
-	reaper := NewReaper(ctx, mockExec, mockSeq, chainID, interval, logger, store)
+	reaper := NewReaper(t.Context(), mockExec, mockSeq, chainID, interval, logger, store)
 
 	// Mock GetTxs returning no transactions
 	mockExec.On("GetTxs", mock.Anything).Return([][]byte{}, nil).Once()
@@ -80,8 +75,6 @@ func TestReaper_SubmitTxs_NoTxs(t *testing.T) {
 
 func TestReaper_TxPersistence_AcrossRestarts(t *testing.T) {
 	require := require.New(t)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
 
 	// Use separate mocks for each instance but share the store
 	mockExec1 := testmocks.NewExecutor(t)
@@ -100,7 +93,7 @@ func TestReaper_TxPersistence_AcrossRestarts(t *testing.T) {
 	txKey := ds.NewKey(hex.EncodeToString(txHash[:]))
 
 	// First reaper instance
-	reaper1 := NewReaper(ctx, mockExec1, mockSeq1, chainID, interval, logger, store)
+	reaper1 := NewReaper(t.Context(), mockExec1, mockSeq1, chainID, interval, logger, store)
 
 	// Mock interactions for the first instance
 	mockExec1.On("GetTxs", mock.Anything).Return([][]byte{tx}, nil).Once()
@@ -112,12 +105,12 @@ func TestReaper_TxPersistence_AcrossRestarts(t *testing.T) {
 	reaper1.SubmitTxs()
 
 	// Verify the tx was marked as seen in the real store after the first run
-	has, err := store.Has(ctx, txKey)
+	has, err := store.Has(t.Context(), txKey)
 	require.NoError(err)
 	require.True(has, "Transaction should be marked as seen in the datastore after first submission")
 
 	// Create a new reaper instance simulating a restart
-	reaper2 := NewReaper(ctx, mockExec2, mockSeq2, chainID, interval, logger, store)
+	reaper2 := NewReaper(t.Context(), mockExec2, mockSeq2, chainID, interval, logger, store)
 
 	// Mock interactions for the second instance
 	mockExec2.On("GetTxs", mock.Anything).Return([][]byte{tx}, nil).Once()
diff --git a/block/submitter.go b/block/submitter.go
@@ -110,9 +110,7 @@ daSubmitRetryLoop:
 			maxBlobSize = initialMaxBlobSize
 			if m.gasMultiplier > 0 && gasPrice != -1 {
 				gasPrice = gasPrice / m.gasMultiplier
-				if gasPrice < initialGasPrice {
-					gasPrice = initialGasPrice
-				}
+				gasPrice = max(gasPrice, initialGasPrice)
 			}
 			m.logger.Debug("resetting DA layer submission options", "backoff", backoff, "gasPrice", gasPrice, "maxBlobSize", maxBlobSize)
 		case coreda.StatusNotIncludedInBlock, coreda.StatusAlreadyInMempool:
diff --git a/node/full_node_integration_test.go b/node/full_node_integration_test.go
@@ -145,7 +145,7 @@ func (s *FullNodeTestSuite) SetupTest() {
 	s.T().Logf("DA client initialized: %v", s.node.blockManager.DALCInitialized())
 
 	// Wait longer for height to stabilize and log intermediate values
-	for i := 0; i < 5; i++ {
+	for range 5 {
 		time.Sleep(200 * time.Millisecond)
 		currentHeight, err := s.node.Store.Height(s.ctx)
 		require.NoError(err)
@@ -236,7 +236,7 @@ func (s *FullNodeTestSuite) TestSubmitBlocksToDA() {
 
 	// Monitor batch retrieval
 	s.T().Log("=== Monitoring Batch Retrieval ===")
-	for i := 0; i < 5; i++ {
+	for i := range 5 {
 		time.Sleep(200 * time.Millisecond)
 		// We can't directly check batch queue size, but we can monitor block production
 		currentHeight, err := s.node.Store.Height(s.ctx)
@@ -252,7 +252,7 @@ func (s *FullNodeTestSuite) TestSubmitBlocksToDA() {
 	s.node.blockManager.SetLastState(currentState)
 
 	// Monitor after trigger
-	for i := 0; i < 5; i++ {
+	for i := range 5 {
 		time.Sleep(200 * time.Millisecond)
 		currentHeight, err := s.node.Store.Height(s.ctx)
 		require.NoError(err)
@@ -288,7 +288,7 @@ func (s *FullNodeTestSuite) TestDAInclusion() {
 
 	// Monitor state changes in shorter intervals
 	s.T().Log("=== Monitoring State Changes ===")
-	for i := 0; i < 10; i++ {
+	for i := range 10 {
 		time.Sleep(200 * time.Millisecond)
 		currentHeight, err := s.node.Store.Height(s.ctx)
 		require.NoError(err)
diff --git a/node/helpers.go b/node/helpers.go
@@ -34,10 +34,10 @@ func (m MockTester) Fail() {}
 func (m MockTester) FailNow() {}
 
 // Logf is used to log a message to the test logger
-func (m MockTester) Logf(format string, args ...interface{}) {}
+func (m MockTester) Logf(format string, args ...any) {}
 
 // Errorf is used to log an error to the test logger
-func (m MockTester) Errorf(format string, args ...interface{}) {}
+func (m MockTester) Errorf(format string, args ...any) {}
 
 func waitForFirstBlock(node Node, source Source) error {
 	return waitForAtLeastNBlocks(node, 1, source)
diff --git a/pkg/cache/cache_test.go b/pkg/cache/cache_test.go
@@ -99,7 +99,7 @@ func TestCacheConcurrency(t *testing.T) {
 	var wg sync.WaitGroup
 	wg.Add(goroutines)
 
-	for i := 0; i < goroutines; i++ {
+	for i := range goroutines {
 		go func(id int) {
 			defer wg.Done()
 			for j := 0; j < operations; j++ {
diff --git a/pkg/cmd/run_node_test.go b/pkg/cmd/run_node_test.go
@@ -99,8 +99,8 @@ func TestParseFlags(t *testing.T) {
 
 	testCases := []struct {
 		name     string
-		got      interface{}
-		expected interface{}
+		got      any
+		expected any
 	}{
 		{"RootDir", nodeConfig.RootDir, "custom/root/dir"},
 		{"DBPath", nodeConfig.DBPath, "custom/db/path"},
diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go
@@ -276,7 +276,7 @@ signer:
 	require.Equal(t, "something/config", cfgFromViper.Signer.SignerPath, "Signer.SignerPath should match YAML")
 }
 
-func assertFlagValue(t *testing.T, flags *pflag.FlagSet, name string, expectedValue interface{}) {
+func assertFlagValue(t *testing.T, flags *pflag.FlagSet, name string, expectedValue any) {
 	flag := flags.Lookup(name)
 	assert.NotNil(t, flag, "Flag %s should exist", name)
 	if flag != nil {
diff --git a/pkg/genesis/io_test.go b/pkg/genesis/io_test.go
@@ -94,7 +94,7 @@ func TestLoadAndSaveGenesis(t *testing.T) {
 			// Verify file contents are valid JSON
 			fileContent, err := os.ReadFile(filepath.Clean(tmpFile))
 			assert.NoError(t, err)
-			var jsonContent map[string]interface{}
+			var jsonContent map[string]any
 			err = json.Unmarshal(fileContent, &jsonContent)
 			assert.NoError(t, err)
 		})
diff --git a/pkg/os/os.go b/pkg/os/os.go
@@ -10,7 +10,7 @@ import (
 )
 
 type logger interface {
-	Info(msg string, keyvals ...interface{})
+	Info(msg string, keyvals ...any)
 }
 
 // TrapSignal catches the SIGTERM/SIGINT and executes cb function. After that it exits
diff --git a/pkg/os/os_test.go b/pkg/os/os_test.go
@@ -10,10 +10,10 @@ import (
 
 type mockLogger struct {
 	lastMsg string
-	lastKV  []interface{}
+	lastKV  []any
 }
 
-func (m *mockLogger) Info(msg string, keyvals ...interface{}) {
+func (m *mockLogger) Info(msg string, keyvals ...any) {
 	m.lastMsg = msg
 	m.lastKV = keyvals
 }
diff --git a/pkg/p2p/client_test.go b/pkg/p2p/client_test.go
@@ -82,9 +82,7 @@ func TestBootstrapping(t *testing.T) {
 	assert := assert.New(t)
 	logger := log.NewTestLogger(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	clients := startTestNetwork(ctx, t, 4, map[int]hostDescr{
+	clients := startTestNetwork(t.Context(), t, 4, map[int]hostDescr{
 		1: {conns: []int{0}},
 		2: {conns: []int{0, 1}},
 		3: {conns: []int{0}},
@@ -105,9 +103,7 @@ func TestDiscovery(t *testing.T) {
 	assert := assert.New(t)
 	logger := log.NewTestLogger(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	clients := startTestNetwork(ctx, t, 5, map[int]hostDescr{
+	clients := startTestNetwork(t.Context(), t, 5, map[int]hostDescr{
 		1: {conns: []int{0}, chainID: "ORU2"},
 		2: {conns: []int{0}, chainID: "ORU2"},
 		3: {conns: []int{1}, chainID: "ORU1"},
diff --git a/pkg/p2p/utils_test.go b/pkg/p2p/utils_test.go
@@ -57,7 +57,8 @@ func getAddr(sk crypto.PrivKey) (multiaddr.Multiaddr, error) {
 	if len(id) > 8 {
 		suffix = id[len(id)-8:]
 	}
-	ip := append(net.IP{}, unicastAddr...)
+	ip := make(net.IP, len(unicastAddr))
+	copy(ip, unicastAddr)
 	copy(ip[net.IPv6len-len(suffix):], suffix)
 	a, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip6/%s/tcp/4242", ip))
 	if err != nil {
@@ -106,7 +107,7 @@ func startTestNetwork(ctx context.Context, t *testing.T, n int, conf map[int]hos
 	}
 
 	clients := make([]*Client, n)
-	for i := 0; i < n; i++ {
+	for i := range seeds {
 		tempDir := filepath.Join(t.TempDir(), fmt.Sprintf("client_%d", i))
 		ClientInitFiles(t, tempDir)
 		nodeKey, err := key.GenerateNodeKey()
diff --git a/pkg/store/prefix_test.go b/pkg/store/prefix_test.go
diff --git a/pkg/store/store_test.go b/pkg/store/store_test.go
diff --git a/test/e2e/sut_helper.go b/test/e2e/sut_helper.go
diff --git a/types/utils.go b/types/utils.go
diff --git a/types/utils_test.go b/types/utils_test.go

Original file line number	Diff line number	Diff line change
`@@ -276,7 +276,7 @@ signer:`
`276`	`276`	`require.Equal(t, "something/config", cfgFromViper.Signer.SignerPath, "Signer.SignerPath should match YAML")`
`277`	`277`	`}`
`278`	`278`
`279`		`-func assertFlagValue(t testing.T, flags pflag.FlagSet, name string, expectedValue interface{}) {`
	`279`	`+func assertFlagValue(t testing.T, flags pflag.FlagSet, name string, expectedValue any) {`
`280`	`280`	`flag := flags.Lookup(name)`
`281`	`281`	`assert.NotNil(t, flag, "Flag %s should exist", name)`
`282`	`282`	`if flag != nil {`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ import (`
`10`	`10`	`)`
`11`	`11`
`12`	`12`	`type logger interface {`
`13`		`- Info(msg string, keyvals ...interface{})`
	`13`	`+ Info(msg string, keyvals ...any)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`// TrapSignal catches the SIGTERM/SIGINT and executes cb function. After that it exits`