From a51fb60e37f648c7986ddae0ba808de550bc20ea Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Tue, 16 Jan 2024 19:21:41 -0600 Subject: [PATCH 01/26] Fix block submission --- block/manager.go | 1 + 1 file changed, 1 insertion(+) diff --git a/block/manager.go b/block/manager.go index 517a855fe5..d86e550901 100644 --- a/block/manager.go +++ b/block/manager.go @@ -839,6 +839,7 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { submitted = true } submittedBlocks := blocks[:res.SubmittedCount] + blocks = blocks[res.SubmittedCount:] for _, block := range submittedBlocks { m.blockCache.setDAIncluded(block.Hash().String()) } From 44ceea878c56664cd74a3f8fb536657183bd6353 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Tue, 16 Jan 2024 19:29:16 -0600 Subject: [PATCH 02/26] Clean up documentation --- block/manager.go | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/block/manager.go b/block/manager.go index d86e550901..754e468ea9 100644 --- a/block/manager.go +++ b/block/manager.go @@ -829,17 +829,18 @@ func (m *Manager) recordMetrics(block *types.Block) { func (m *Manager) submitBlocksToDA(ctx context.Context) error { submitted := false backoff := initialBackoff - blocks := m.pendingBlocks.getPendingBlocks() + blocksToSubmit := m.pendingBlocks.getPendingBlocks() for attempt := 1; ctx.Err() == nil && !submitted && attempt <= maxSubmitAttempts; attempt++ { - res := m.dalc.SubmitBlocks(ctx, blocks) + res := m.dalc.SubmitBlocks(ctx, blocksToSubmit) switch res.Code { case da.StatusSuccess: m.logger.Info("successfully submitted Rollkit block to DA layer", "daHeight", res.DAHeight, "count", res.SubmittedCount) - if int(res.SubmittedCount) == len(blocks) { + if int(res.SubmittedCount) == len(blocksToSubmit) { submitted = true } - submittedBlocks := blocks[:res.SubmittedCount] - blocks = blocks[res.SubmittedCount:] + submittedBlocks := blocksToSubmit[:res.SubmittedCount] + // blocksToSubmit should only contain blocks that have not been submitted + blocksToSubmit = blocksToSubmit[res.SubmittedCount:] for _, block := range submittedBlocks { m.blockCache.setDAIncluded(block.Hash().String()) } From 477ed55ace1c4281b223aadb0c785b21690f4805 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Tue, 16 Jan 2024 20:34:34 -0600 Subject: [PATCH 03/26] Clean up code --- block/manager.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/block/manager.go b/block/manager.go index 754e468ea9..8e13c3f4a5 100644 --- a/block/manager.go +++ b/block/manager.go @@ -838,13 +838,12 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { if int(res.SubmittedCount) == len(blocksToSubmit) { submitted = true } - submittedBlocks := blocksToSubmit[:res.SubmittedCount] - // blocksToSubmit should only contain blocks that have not been submitted - blocksToSubmit = blocksToSubmit[res.SubmittedCount:] + submittedBlocks, notSubmittedBlocks := blocksToSubmit[:res.SubmittedCount], blocksToSubmit[res.SubmittedCount:] for _, block := range submittedBlocks { m.blockCache.setDAIncluded(block.Hash().String()) } m.pendingBlocks.removeSubmittedBlocks(submittedBlocks) + blocksToSubmit = notSubmittedBlocks case da.StatusError, da.StatusNotFound: m.logger.Error("DA layer submission failed", "error", res.Message, "attempt", attempt) time.Sleep(backoff) From b89ff43caefb9178e4c8e29fbffa12054af363b6 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Fri, 19 Jan 2024 11:12:17 -0600 Subject: [PATCH 04/26] track num submitted blocks --- block/manager.go | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/block/manager.go b/block/manager.go index 8e13c3f4a5..24581dff75 100644 --- a/block/manager.go +++ b/block/manager.go @@ -827,18 +827,21 @@ func (m *Manager) recordMetrics(block *types.Block) { } func (m *Manager) submitBlocksToDA(ctx context.Context) error { - submitted := false + submittedAll := false backoff := initialBackoff blocksToSubmit := m.pendingBlocks.getPendingBlocks() - for attempt := 1; ctx.Err() == nil && !submitted && attempt <= maxSubmitAttempts; attempt++ { + numTotalBlocks := len(blocksToSubmit) + numSubmittedBlocks := 0 + for attempt := 1; ctx.Err() == nil && !submittedAll && attempt <= maxSubmitAttempts; attempt++ { res := m.dalc.SubmitBlocks(ctx, blocksToSubmit) switch res.Code { case da.StatusSuccess: m.logger.Info("successfully submitted Rollkit block to DA layer", "daHeight", res.DAHeight, "count", res.SubmittedCount) if int(res.SubmittedCount) == len(blocksToSubmit) { - submitted = true + submittedAll = true } submittedBlocks, notSubmittedBlocks := blocksToSubmit[:res.SubmittedCount], blocksToSubmit[res.SubmittedCount:] + numSubmittedBlocks += len(submittedBlocks) for _, block := range submittedBlocks { m.blockCache.setDAIncluded(block.Hash().String()) } @@ -855,8 +858,13 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { } } - if !submitted { - return fmt.Errorf("failed to submit block to DA layer after %d attempts", maxSubmitAttempts) + if !submittedAll { + return fmt.Errorf( + "failed to submit all blocks to DA layer, submitted %d of %d blocks after %d attempts", + numSubmittedBlocks, + numTotalBlocks, + maxSubmitAttempts, + ) } return nil } From 77562ffde932b946f9bd4ff8f88ad1c8c6153e7a Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Fri, 19 Jan 2024 15:44:45 -0600 Subject: [PATCH 05/26] Minor type cast changes --- block/manager.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/block/manager.go b/block/manager.go index 24581dff75..7c81e8c952 100644 --- a/block/manager.go +++ b/block/manager.go @@ -831,17 +831,17 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { backoff := initialBackoff blocksToSubmit := m.pendingBlocks.getPendingBlocks() numTotalBlocks := len(blocksToSubmit) - numSubmittedBlocks := 0 + numSubmittedBlocks := uint64(0) for attempt := 1; ctx.Err() == nil && !submittedAll && attempt <= maxSubmitAttempts; attempt++ { res := m.dalc.SubmitBlocks(ctx, blocksToSubmit) switch res.Code { case da.StatusSuccess: - m.logger.Info("successfully submitted Rollkit block to DA layer", "daHeight", res.DAHeight, "count", res.SubmittedCount) - if int(res.SubmittedCount) == len(blocksToSubmit) { + m.logger.Info("successfully submitted Rollkit blocks to DA layer", "daHeight", res.DAHeight, "count", res.SubmittedCount) + if res.SubmittedCount == uint64(len(blocksToSubmit)) { submittedAll = true } submittedBlocks, notSubmittedBlocks := blocksToSubmit[:res.SubmittedCount], blocksToSubmit[res.SubmittedCount:] - numSubmittedBlocks += len(submittedBlocks) + numSubmittedBlocks += uint64(len(submittedBlocks)) for _, block := range submittedBlocks { m.blockCache.setDAIncluded(block.Hash().String()) } @@ -852,7 +852,7 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { time.Sleep(backoff) backoff = m.exponentialBackoff(backoff) default: - m.logger.Error("DA layer unknown status", "error", res.Message, "attempt", attempt) + m.logger.Error("DA layer unknown status response", "error", res.Message, "attempt", attempt) time.Sleep(backoff) backoff = m.exponentialBackoff(backoff) } From bb484983fe51f55fb47e206bd6ccad9d799f4a89 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Tue, 23 Jan 2024 16:25:45 -0600 Subject: [PATCH 06/26] Add happy case test --- block/manager_test.go | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/block/manager_test.go b/block/manager_test.go index 76347d8b19..c822c4e245 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -94,3 +94,32 @@ func TestIsDAIncluded(t *testing.T) { m.blockCache.setDAIncluded(hash.String()) require.True(m.IsDAIncluded(hash)) } + +// Happy case, all blocks A, B, C are submitted on first round +func TestSubmitBlocksToDAHappy(t *testing.T) { + require := require.New(t) + ctx := context.Background() + logger := test.NewFileLoggerCustom(t, test.TempLogFileName(t, t.Name())) + + // Create a minimalistic block manager + m := &Manager{ + dalc: &da.DAClient{DA: goDATest.NewDummyDA(), GasPrice: -1, Logger: logger}, + blockCache: NewBlockCache(), + pendingBlocks: NewPendingBlocks(), + logger: logger, + } + + // Prepare blocks A, B, C to add to manager's pendingBlocks + numTxs, numBlocks := 3, 5 + blocks := make([]*types.Block, numBlocks) + for i := 0; i < numBlocks; i++ { + blocks[i] = types.GetRandomBlock(uint64(i), numTxs) + m.pendingBlocks.addPendingBlock(blocks[i]) + } + + err := m.submitBlocksToDA(ctx) + require.NoError(err) + + // Blocks A and B are submitted first round because including c triggers size limit. C is then submitted on second round. + +} From f4959a9c453d6e511a4eec0aee8ae9c5c755faa6 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Fri, 2 Feb 2024 03:02:29 +0400 Subject: [PATCH 07/26] Fix lint --- block/manager_test.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/block/manager_test.go b/block/manager_test.go index c822c4e245..bc5dc4896d 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -7,7 +7,10 @@ import ( cmtypes "github.com/cometbft/cometbft/types" "github.com/stretchr/testify/require" + goDATest "github.com/rollkit/go-da/test" + "github.com/rollkit/rollkit/da" "github.com/rollkit/rollkit/store" + test "github.com/rollkit/rollkit/test/log" "github.com/rollkit/rollkit/types" ) From 19d5c42c5448228caa6bd9df4c6642df8d0cf139 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 01:56:54 +0400 Subject: [PATCH 08/26] Return numAttempts in submitBlocksToDA --- block/manager.go | 14 ++++++++------ block/manager_test.go | 3 ++- da/da.go | 2 +- 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/block/manager.go b/block/manager.go index 7c81e8c952..9b161bbf81 100644 --- a/block/manager.go +++ b/block/manager.go @@ -330,7 +330,7 @@ func (m *Manager) BlockSubmissionLoop(ctx context.Context) { if m.pendingBlocks.isEmpty() { continue } - err := m.submitBlocksToDA(ctx) + _, err := m.submitBlocksToDA(ctx) if err != nil { m.logger.Error("error while submitting block to DA", "error", err) } @@ -826,13 +826,13 @@ func (m *Manager) recordMetrics(block *types.Block) { m.metrics.CommittedHeight.Set(float64(block.Height())) } -func (m *Manager) submitBlocksToDA(ctx context.Context) error { +func (m *Manager) submitBlocksToDA(ctx context.Context) (uint64, error) { submittedAll := false backoff := initialBackoff blocksToSubmit := m.pendingBlocks.getPendingBlocks() numTotalBlocks := len(blocksToSubmit) - numSubmittedBlocks := uint64(0) - for attempt := 1; ctx.Err() == nil && !submittedAll && attempt <= maxSubmitAttempts; attempt++ { + numSubmittedBlocks, attempt := uint64(0), uint64(0) + for ctx.Err() == nil && !submittedAll && attempt < maxSubmitAttempts { res := m.dalc.SubmitBlocks(ctx, blocksToSubmit) switch res.Code { case da.StatusSuccess: @@ -847,6 +847,7 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { } m.pendingBlocks.removeSubmittedBlocks(submittedBlocks) blocksToSubmit = notSubmittedBlocks + case da.StatusError, da.StatusNotFound: m.logger.Error("DA layer submission failed", "error", res.Message, "attempt", attempt) time.Sleep(backoff) @@ -856,17 +857,18 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { time.Sleep(backoff) backoff = m.exponentialBackoff(backoff) } + attempt += 1 } if !submittedAll { - return fmt.Errorf( + return attempt, fmt.Errorf( "failed to submit all blocks to DA layer, submitted %d of %d blocks after %d attempts", numSubmittedBlocks, numTotalBlocks, maxSubmitAttempts, ) } - return nil + return attempt, nil } func (m *Manager) exponentialBackoff(backoff time.Duration) time.Duration { diff --git a/block/manager_test.go b/block/manager_test.go index bc5dc4896d..5dfbe9ddbe 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -120,8 +120,9 @@ func TestSubmitBlocksToDAHappy(t *testing.T) { m.pendingBlocks.addPendingBlock(blocks[i]) } - err := m.submitBlocksToDA(ctx) + numAttempts, err := m.submitBlocksToDA(ctx) require.NoError(err) + require.Equal(numAttempts, uint64(1)) // Blocks A and B are submitted first round because including c triggers size limit. C is then submitted on second round. diff --git a/da/da.go b/da/da.go index 2675d2670c..66825779f2 100644 --- a/da/da.go +++ b/da/da.go @@ -83,7 +83,7 @@ type DAClient struct { // SubmitBlocks submits blocks to DA. func (dac *DAClient) SubmitBlocks(ctx context.Context, blocks []*types.Block) ResultSubmitBlocks { var blobs [][]byte - var blobSize uint64 + blobSize := uint64(0) maxBlobSize, err := dac.DA.MaxBlobSize(ctx) if err != nil { return ResultSubmitBlocks{ From ed476be01b5024dbbacd66c1590fef3024372fdd Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 02:51:35 +0400 Subject: [PATCH 09/26] Add two more test cases for block submission --- block/manager_test.go | 52 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 50 insertions(+), 2 deletions(-) diff --git a/block/manager_test.go b/block/manager_test.go index 5dfbe9ddbe..2692afa259 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -113,10 +113,10 @@ func TestSubmitBlocksToDAHappy(t *testing.T) { } // Prepare blocks A, B, C to add to manager's pendingBlocks - numTxs, numBlocks := 3, 5 + numTxs, numBlocks := 5, 3 blocks := make([]*types.Block, numBlocks) for i := 0; i < numBlocks; i++ { - blocks[i] = types.GetRandomBlock(uint64(i), numTxs) + blocks[i] = types.GetRandomBlock(uint64(i+1), numTxs) m.pendingBlocks.addPendingBlock(blocks[i]) } @@ -125,5 +125,53 @@ func TestSubmitBlocksToDAHappy(t *testing.T) { require.Equal(numAttempts, uint64(1)) // Blocks A and B are submitted first round because including c triggers size limit. C is then submitted on second round. + limit, err := m.dalc.DA.MaxBlobSize(ctx) + require.NoError(err) + + // Find three blocks where two of them are under blob size limit + // but adding the third one exceeds the blob size limit + var block1, block2, block3 *types.Block + for numTxs := 0; ; numTxs += 100 { + block1 = types.GetRandomBlock(1, numTxs) + blob1, err := block1.MarshalBinary() + require.NoError(err) + + block2 = types.GetRandomBlock(2, numTxs) + blob2, err := block2.MarshalBinary() + require.NoError(err) + + block3 = types.GetRandomBlock(3, numTxs) + blob3, err := block3.MarshalBinary() + require.NoError(err) + + if uint64(len(blob1)+len(blob2)) < limit && uint64(len(blob1)+len(blob2)+len(blob3)) > limit { + m.pendingBlocks.addPendingBlock(block1) + m.pendingBlocks.addPendingBlock(block2) + m.pendingBlocks.addPendingBlock(block3) + break + } + } + numAttempts, err = m.submitBlocksToDA(ctx) + require.NoError(err) + require.Equal(numAttempts, uint64(2)) + + // A and B are submitted successful but C is too big on its own, so C never gets submitted + for i := 0; i < numBlocks-1; i++ { + blocks[i] = types.GetRandomBlock(uint64(i+1), numTxs) + m.pendingBlocks.addPendingBlock(blocks[i]) + } + for numTxs := 0; ; numTxs += 100 { + block3 = types.GetRandomBlock(3, numTxs) + blob3, err := block3.MarshalBinary() + require.NoError(err) + + if uint64(len(blob3)) > limit { + m.pendingBlocks.addPendingBlock(block3) + break + } + } + numAttempts, err = m.submitBlocksToDA(ctx) + require.NotNil(err) + require.Equal(numAttempts, uint64(maxSubmitAttempts)) } From 3f6a1c2850d9fd907459c28f332809c92fb1da83 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 03:17:43 +0400 Subject: [PATCH 10/26] Refactor tests into table driven tests --- block/manager_test.go | 141 +++++++++++++++++++++++------------------- da/da.go | 2 +- 2 files changed, 79 insertions(+), 64 deletions(-) diff --git a/block/manager_test.go b/block/manager_test.go index 2692afa259..ac12d3cae0 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -5,6 +5,7 @@ import ( "testing" cmtypes "github.com/cometbft/cometbft/types" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" goDATest "github.com/rollkit/go-da/test" @@ -98,80 +99,94 @@ func TestIsDAIncluded(t *testing.T) { require.True(m.IsDAIncluded(hash)) } -// Happy case, all blocks A, B, C are submitted on first round -func TestSubmitBlocksToDAHappy(t *testing.T) { +func TestSubmitBlocks(t *testing.T) { require := require.New(t) ctx := context.Background() logger := test.NewFileLoggerCustom(t, test.TempLogFileName(t, t.Name())) // Create a minimalistic block manager m := &Manager{ - dalc: &da.DAClient{DA: goDATest.NewDummyDA(), GasPrice: -1, Logger: logger}, - blockCache: NewBlockCache(), - pendingBlocks: NewPendingBlocks(), - logger: logger, - } - - // Prepare blocks A, B, C to add to manager's pendingBlocks - numTxs, numBlocks := 5, 3 - blocks := make([]*types.Block, numBlocks) - for i := 0; i < numBlocks; i++ { - blocks[i] = types.GetRandomBlock(uint64(i+1), numTxs) - m.pendingBlocks.addPendingBlock(blocks[i]) + dalc: &da.DAClient{DA: goDATest.NewDummyDA(), GasPrice: -1, Logger: logger}, + blockCache: NewBlockCache(), + logger: logger, } - numAttempts, err := m.submitBlocksToDA(ctx) - require.NoError(err) - require.Equal(numAttempts, uint64(1)) - - // Blocks A and B are submitted first round because including c triggers size limit. C is then submitted on second round. - limit, err := m.dalc.DA.MaxBlobSize(ctx) + maxDABlobSizeLimit, err := m.dalc.DA.MaxBlobSize(ctx) require.NoError(err) - // Find three blocks where two of them are under blob size limit - // but adding the third one exceeds the blob size limit - var block1, block2, block3 *types.Block - for numTxs := 0; ; numTxs += 100 { - block1 = types.GetRandomBlock(1, numTxs) - blob1, err := block1.MarshalBinary() - require.NoError(err) - - block2 = types.GetRandomBlock(2, numTxs) - blob2, err := block2.MarshalBinary() - require.NoError(err) - - block3 = types.GetRandomBlock(3, numTxs) - blob3, err := block3.MarshalBinary() - require.NoError(err) - - if uint64(len(blob1)+len(blob2)) < limit && uint64(len(blob1)+len(blob2)+len(blob3)) > limit { - m.pendingBlocks.addPendingBlock(block1) - m.pendingBlocks.addPendingBlock(block2) - m.pendingBlocks.addPendingBlock(block3) - break - } + testCases := []struct { + name string + blocks []*types.Block + isErrExpected bool + expectedNumAttempts uint64 + }{ + { + name: "happy path, all blocks A, B, C are submitted on first round", + blocks: []*types.Block{types.GetRandomBlock(1, 5), types.GetRandomBlock(2, 5), types.GetRandomBlock(3, 5)}, + isErrExpected: false, + expectedNumAttempts: uint64(1), + }, + { + name: "blocks A and B are submitted first round because including c triggers blob size limit. C is submitted on second round", + blocks: func() []*types.Block { + // Find three blocks where two of them are under blob size limit + // but adding the third one exceeds the blob size limit + var block1, block2, block3 *types.Block + for numTxs := 0; ; numTxs += 100 { + block1 = types.GetRandomBlock(1, numTxs) + blob1, err := block1.MarshalBinary() + require.NoError(err) + + block2 = types.GetRandomBlock(2, numTxs) + blob2, err := block2.MarshalBinary() + require.NoError(err) + + block3 = types.GetRandomBlock(3, numTxs) + blob3, err := block3.MarshalBinary() + require.NoError(err) + + if uint64(len(blob1)+len(blob2)) < maxDABlobSizeLimit && uint64(len(blob1)+len(blob2)+len(blob3)) > maxDABlobSizeLimit { + return []*types.Block{block1, block2, block3} + } + } + }(), + isErrExpected: false, + expectedNumAttempts: uint64(2), + }, + { + name: "A and B are submitted successfully but C is too big on its own, so C never gets submitted", + blocks: func() []*types.Block { + numBlocks, numTxs := 3, 5 + blocks := make([]*types.Block, numBlocks) + for i := 0; i < numBlocks-1; i++ { + blocks[i] = types.GetRandomBlock(uint64(i+1), numTxs) + } + for numTxs := 0; ; numTxs += 100 { + block3 := types.GetRandomBlock(3, numTxs) + blob3, err := block3.MarshalBinary() + require.NoError(err) + + if uint64(len(blob3)) > maxDABlobSizeLimit { + blocks[2] = block3 + return blocks + } + } + }(), + isErrExpected: true, + expectedNumAttempts: uint64(maxSubmitAttempts), + }, } - numAttempts, err = m.submitBlocksToDA(ctx) - require.NoError(err) - require.Equal(numAttempts, uint64(2)) - // A and B are submitted successful but C is too big on its own, so C never gets submitted - for i := 0; i < numBlocks-1; i++ { - blocks[i] = types.GetRandomBlock(uint64(i+1), numTxs) - m.pendingBlocks.addPendingBlock(blocks[i]) - } - for numTxs := 0; ; numTxs += 100 { - block3 = types.GetRandomBlock(3, numTxs) - blob3, err := block3.MarshalBinary() - require.NoError(err) - - if uint64(len(blob3)) > limit { - m.pendingBlocks.addPendingBlock(block3) - break - } + // Prepare blocks A, B, C to add to manager's pendingBlocks + for _, tc := range testCases { + m.pendingBlocks = NewPendingBlocks() + t.Run(tc.name, func(t *testing.T) { + for _, block := range tc.blocks { + m.pendingBlocks.addPendingBlock(block) + } + numAttempts, err := m.submitBlocksToDA(ctx) + assert.Equal(t, tc.isErrExpected, err != nil) + assert.Equal(t, tc.expectedNumAttempts, numAttempts) + }) } - numAttempts, err = m.submitBlocksToDA(ctx) - require.NotNil(err) - require.Equal(numAttempts, uint64(maxSubmitAttempts)) - } diff --git a/da/da.go b/da/da.go index 66825779f2..cefc3adfae 100644 --- a/da/da.go +++ b/da/da.go @@ -93,7 +93,7 @@ func (dac *DAClient) SubmitBlocks(ctx context.Context, blocks []*types.Block) Re }, } } - var submitted uint64 + var submitted = uint64(0) for i := range blocks { blob, err := blocks[i].MarshalBinary() if err != nil { From 29d28c0941d2bbe542e5dba3fd1aa56ff2290e14 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 03:24:02 +0400 Subject: [PATCH 11/26] Remove redundant comment --- block/manager_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/block/manager_test.go b/block/manager_test.go index ac12d3cae0..9f8b6c01a9 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -177,7 +177,6 @@ func TestSubmitBlocks(t *testing.T) { }, } - // Prepare blocks A, B, C to add to manager's pendingBlocks for _, tc := range testCases { m.pendingBlocks = NewPendingBlocks() t.Run(tc.name, func(t *testing.T) { From a63fc2c8ea2574d30479e4800c5fff37bf1f117b Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 03:45:05 +0400 Subject: [PATCH 12/26] Update da/da.go Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- da/da.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/da/da.go b/da/da.go index cefc3adfae..e472691aba 100644 --- a/da/da.go +++ b/da/da.go @@ -83,7 +83,7 @@ type DAClient struct { // SubmitBlocks submits blocks to DA. func (dac *DAClient) SubmitBlocks(ctx context.Context, blocks []*types.Block) ResultSubmitBlocks { var blobs [][]byte - blobSize := uint64(0) + var blobSize uint64 maxBlobSize, err := dac.DA.MaxBlobSize(ctx) if err != nil { return ResultSubmitBlocks{ From c48ed750db11ae419fcca0761fa0b39d09692d2c Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 03:45:14 +0400 Subject: [PATCH 13/26] Update da/da.go Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- da/da.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/da/da.go b/da/da.go index e472691aba..2675d2670c 100644 --- a/da/da.go +++ b/da/da.go @@ -93,7 +93,7 @@ func (dac *DAClient) SubmitBlocks(ctx context.Context, blocks []*types.Block) Re }, } } - var submitted = uint64(0) + var submitted uint64 for i := range blocks { blob, err := blocks[i].MarshalBinary() if err != nil { From 2e83fa87bf9bf834717c64288ddc60aed3301b6d Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 17:28:07 +0400 Subject: [PATCH 14/26] Update block/manager.go MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Tomasz Zdybał --- block/manager.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/block/manager.go b/block/manager.go index 9b161bbf81..79621eef0d 100644 --- a/block/manager.go +++ b/block/manager.go @@ -831,7 +831,8 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) (uint64, error) { backoff := initialBackoff blocksToSubmit := m.pendingBlocks.getPendingBlocks() numTotalBlocks := len(blocksToSubmit) - numSubmittedBlocks, attempt := uint64(0), uint64(0) + attempt := uint64(0) + numSubmittedBlocks := uint64(0) for ctx.Err() == nil && !submittedAll && attempt < maxSubmitAttempts { res := m.dalc.SubmitBlocks(ctx, blocksToSubmit) switch res.Code { From 9933fe2cbc9b02f2ecaf11384c51ed567de47c22 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 18:30:01 +0400 Subject: [PATCH 15/26] Remove attempts from submitBlockToDA --- block/manager.go | 8 ++++---- block/manager_test.go | 34 ++++++++++------------------------ block/utils.go | 19 +++++++++++++++++++ 3 files changed, 33 insertions(+), 28 deletions(-) create mode 100644 block/utils.go diff --git a/block/manager.go b/block/manager.go index 79621eef0d..8ef03aed23 100644 --- a/block/manager.go +++ b/block/manager.go @@ -330,7 +330,7 @@ func (m *Manager) BlockSubmissionLoop(ctx context.Context) { if m.pendingBlocks.isEmpty() { continue } - _, err := m.submitBlocksToDA(ctx) + err := m.submitBlocksToDA(ctx) if err != nil { m.logger.Error("error while submitting block to DA", "error", err) } @@ -826,7 +826,7 @@ func (m *Manager) recordMetrics(block *types.Block) { m.metrics.CommittedHeight.Set(float64(block.Height())) } -func (m *Manager) submitBlocksToDA(ctx context.Context) (uint64, error) { +func (m *Manager) submitBlocksToDA(ctx context.Context) error { submittedAll := false backoff := initialBackoff blocksToSubmit := m.pendingBlocks.getPendingBlocks() @@ -862,14 +862,14 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) (uint64, error) { } if !submittedAll { - return attempt, fmt.Errorf( + return fmt.Errorf( "failed to submit all blocks to DA layer, submitted %d of %d blocks after %d attempts", numSubmittedBlocks, numTotalBlocks, maxSubmitAttempts, ) } - return attempt, nil + return nil } func (m *Manager) exponentialBackoff(backoff time.Duration) time.Duration { diff --git a/block/manager_test.go b/block/manager_test.go index 9f8b6c01a9..3f199fb521 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -8,10 +8,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - goDATest "github.com/rollkit/go-da/test" - "github.com/rollkit/rollkit/da" "github.com/rollkit/rollkit/store" - test "github.com/rollkit/rollkit/test/log" "github.com/rollkit/rollkit/types" ) @@ -102,29 +99,21 @@ func TestIsDAIncluded(t *testing.T) { func TestSubmitBlocks(t *testing.T) { require := require.New(t) ctx := context.Background() - logger := test.NewFileLoggerCustom(t, test.TempLogFileName(t, t.Name())) - // Create a minimalistic block manager - m := &Manager{ - dalc: &da.DAClient{DA: goDATest.NewDummyDA(), GasPrice: -1, Logger: logger}, - blockCache: NewBlockCache(), - logger: logger, - } + m := getManager(t) maxDABlobSizeLimit, err := m.dalc.DA.MaxBlobSize(ctx) require.NoError(err) testCases := []struct { - name string - blocks []*types.Block - isErrExpected bool - expectedNumAttempts uint64 + name string + blocks []*types.Block + isErrExpected bool }{ { - name: "happy path, all blocks A, B, C are submitted on first round", - blocks: []*types.Block{types.GetRandomBlock(1, 5), types.GetRandomBlock(2, 5), types.GetRandomBlock(3, 5)}, - isErrExpected: false, - expectedNumAttempts: uint64(1), + name: "happy path, all blocks A, B, C are submitted on first round", + blocks: []*types.Block{types.GetRandomBlock(1, 5), types.GetRandomBlock(2, 5), types.GetRandomBlock(3, 5)}, + isErrExpected: false, }, { name: "blocks A and B are submitted first round because including c triggers blob size limit. C is submitted on second round", @@ -150,8 +139,7 @@ func TestSubmitBlocks(t *testing.T) { } } }(), - isErrExpected: false, - expectedNumAttempts: uint64(2), + isErrExpected: false, }, { name: "A and B are submitted successfully but C is too big on its own, so C never gets submitted", @@ -172,8 +160,7 @@ func TestSubmitBlocks(t *testing.T) { } } }(), - isErrExpected: true, - expectedNumAttempts: uint64(maxSubmitAttempts), + isErrExpected: true, }, } @@ -183,9 +170,8 @@ func TestSubmitBlocks(t *testing.T) { for _, block := range tc.blocks { m.pendingBlocks.addPendingBlock(block) } - numAttempts, err := m.submitBlocksToDA(ctx) + err := m.submitBlocksToDA(ctx) assert.Equal(t, tc.isErrExpected, err != nil) - assert.Equal(t, tc.expectedNumAttempts, numAttempts) }) } } diff --git a/block/utils.go b/block/utils.go new file mode 100644 index 0000000000..bc5f9a002a --- /dev/null +++ b/block/utils.go @@ -0,0 +1,19 @@ +package block + +import ( + "testing" + + goDATest "github.com/rollkit/go-da/test" + "github.com/rollkit/rollkit/da" + test "github.com/rollkit/rollkit/test/log" +) + +// Returns a minimalistic block manager +func getManager(t *testing.T) *Manager { + logger := test.NewFileLoggerCustom(t, test.TempLogFileName(t, t.Name())) + return &Manager{ + dalc: &da.DAClient{DA: goDATest.NewDummyDA(), GasPrice: -1, Logger: logger}, + blockCache: NewBlockCache(), + logger: logger, + } +} From d29c6d342976126725930ad3eb6e06ea289ac769 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 18:32:18 +0400 Subject: [PATCH 16/26] modify submittedAll to submittedAllBlocks --- block/manager.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/block/manager.go b/block/manager.go index 8ef03aed23..228836ddca 100644 --- a/block/manager.go +++ b/block/manager.go @@ -827,19 +827,19 @@ func (m *Manager) recordMetrics(block *types.Block) { } func (m *Manager) submitBlocksToDA(ctx context.Context) error { - submittedAll := false + submittedAllBlocks := false backoff := initialBackoff blocksToSubmit := m.pendingBlocks.getPendingBlocks() numTotalBlocks := len(blocksToSubmit) attempt := uint64(0) numSubmittedBlocks := uint64(0) - for ctx.Err() == nil && !submittedAll && attempt < maxSubmitAttempts { + for ctx.Err() == nil && !submittedAllBlocks && attempt < maxSubmitAttempts { res := m.dalc.SubmitBlocks(ctx, blocksToSubmit) switch res.Code { case da.StatusSuccess: m.logger.Info("successfully submitted Rollkit blocks to DA layer", "daHeight", res.DAHeight, "count", res.SubmittedCount) if res.SubmittedCount == uint64(len(blocksToSubmit)) { - submittedAll = true + submittedAllBlocks = true } submittedBlocks, notSubmittedBlocks := blocksToSubmit[:res.SubmittedCount], blocksToSubmit[res.SubmittedCount:] numSubmittedBlocks += uint64(len(submittedBlocks)) @@ -861,7 +861,7 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { attempt += 1 } - if !submittedAll { + if !submittedAllBlocks { return fmt.Errorf( "failed to submit all blocks to DA layer, submitted %d of %d blocks after %d attempts", numSubmittedBlocks, From e9c6ba976921d1eb2c3c12569cac3edecadf23cb Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 18:38:57 +0400 Subject: [PATCH 17/26] add expectedPendingBlocksLength --- block/manager_test.go | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/block/manager_test.go b/block/manager_test.go index 3f199fb521..e72ee48b18 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -106,14 +106,16 @@ func TestSubmitBlocks(t *testing.T) { require.NoError(err) testCases := []struct { - name string - blocks []*types.Block - isErrExpected bool + name string + blocks []*types.Block + isErrExpected bool + expectedPendingBlocksLength int }{ { - name: "happy path, all blocks A, B, C are submitted on first round", - blocks: []*types.Block{types.GetRandomBlock(1, 5), types.GetRandomBlock(2, 5), types.GetRandomBlock(3, 5)}, - isErrExpected: false, + name: "happy path, all blocks A, B, C are submitted on first round", + blocks: []*types.Block{types.GetRandomBlock(1, 5), types.GetRandomBlock(2, 5), types.GetRandomBlock(3, 5)}, + isErrExpected: false, + expectedPendingBlocksLength: 0, }, { name: "blocks A and B are submitted first round because including c triggers blob size limit. C is submitted on second round", @@ -139,7 +141,8 @@ func TestSubmitBlocks(t *testing.T) { } } }(), - isErrExpected: false, + isErrExpected: false, + expectedPendingBlocksLength: 0, }, { name: "A and B are submitted successfully but C is too big on its own, so C never gets submitted", @@ -160,7 +163,8 @@ func TestSubmitBlocks(t *testing.T) { } } }(), - isErrExpected: true, + isErrExpected: true, + expectedPendingBlocksLength: 1, }, } @@ -172,6 +176,7 @@ func TestSubmitBlocks(t *testing.T) { } err := m.submitBlocksToDA(ctx) assert.Equal(t, tc.isErrExpected, err != nil) + assert.Equal(t, tc.expectedPendingBlocksLength, len(m.pendingBlocks.getPendingBlocks())) }) } } From a88be8d2f1833fc2934ad289e2c00431ad864687 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 18:57:05 +0400 Subject: [PATCH 18/26] Update block/manager_test.go Co-authored-by: Matthew Sevey --- block/manager_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/block/manager_test.go b/block/manager_test.go index e72ee48b18..96f5bec1d3 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -112,7 +112,7 @@ func TestSubmitBlocks(t *testing.T) { expectedPendingBlocksLength int }{ { - name: "happy path, all blocks A, B, C are submitted on first round", + name: "happy path, all blocks A, B, C combine to less than maxDABlobSize", blocks: []*types.Block{types.GetRandomBlock(1, 5), types.GetRandomBlock(2, 5), types.GetRandomBlock(3, 5)}, isErrExpected: false, expectedPendingBlocksLength: 0, From e2a0f93501241c08e3ca974370d645baa526f87a Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 18:57:25 +0400 Subject: [PATCH 19/26] Update block/manager_test.go Co-authored-by: Matthew Sevey --- block/manager_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/block/manager_test.go b/block/manager_test.go index 96f5bec1d3..5aa91a0309 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -118,7 +118,7 @@ func TestSubmitBlocks(t *testing.T) { expectedPendingBlocksLength: 0, }, { - name: "blocks A and B are submitted first round because including c triggers blob size limit. C is submitted on second round", + name: "blocks A and B are submitted together without C because including C triggers blob size limit. C is submitted in a separate round", blocks: func() []*types.Block { // Find three blocks where two of them are under blob size limit // but adding the third one exceeds the blob size limit From eea654bc501a77c1c9fe80aa7cf61edbb01fd376 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 19:12:17 +0400 Subject: [PATCH 20/26] Clean up --- block/manager_test.go | 13 +++++++++++++ block/utils.go | 19 ------------------- 2 files changed, 13 insertions(+), 19 deletions(-) delete mode 100644 block/utils.go diff --git a/block/manager_test.go b/block/manager_test.go index 5aa91a0309..74710ba75e 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -5,13 +5,26 @@ import ( "testing" cmtypes "github.com/cometbft/cometbft/types" + goDATest "github.com/rollkit/go-da/test" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "github.com/rollkit/rollkit/da" "github.com/rollkit/rollkit/store" + test "github.com/rollkit/rollkit/test/log" "github.com/rollkit/rollkit/types" ) +// Returns a minimalistic block manager +func getManager(t *testing.T) *Manager { + logger := test.NewFileLoggerCustom(t, test.TempLogFileName(t, t.Name())) + return &Manager{ + dalc: &da.DAClient{DA: goDATest.NewDummyDA(), GasPrice: -1, Logger: logger}, + blockCache: NewBlockCache(), + logger: logger, + } +} + func TestInitialStateClean(t *testing.T) { require := require.New(t) genesisDoc, _ := types.GetGenesisWithPrivkey() diff --git a/block/utils.go b/block/utils.go deleted file mode 100644 index bc5f9a002a..0000000000 --- a/block/utils.go +++ /dev/null @@ -1,19 +0,0 @@ -package block - -import ( - "testing" - - goDATest "github.com/rollkit/go-da/test" - "github.com/rollkit/rollkit/da" - test "github.com/rollkit/rollkit/test/log" -) - -// Returns a minimalistic block manager -func getManager(t *testing.T) *Manager { - logger := test.NewFileLoggerCustom(t, test.TempLogFileName(t, t.Name())) - return &Manager{ - dalc: &da.DAClient{DA: goDATest.NewDummyDA(), GasPrice: -1, Logger: logger}, - blockCache: NewBlockCache(), - logger: logger, - } -} From dc532a83de3d87901124dec1d1e82a21b8c3b93f Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 19:21:38 +0400 Subject: [PATCH 21/26] Refactor to extract function getBlockBiggerThan --- block/manager_test.go | 60 ++++++++++++++++++++++--------------------- 1 file changed, 31 insertions(+), 29 deletions(-) diff --git a/block/manager_test.go b/block/manager_test.go index 74710ba75e..2f6a2afd3d 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -25,6 +25,21 @@ func getManager(t *testing.T) *Manager { } } +// getBlockBiggerThan generates a block with the given height bigger than the specified limit. +func getBlockBiggerThan(blockHeight, limit uint64) (*types.Block, error) { + for numTxs := 0; ; numTxs += 100 { + block := types.GetRandomBlock(blockHeight, numTxs) + blob, err := block.MarshalBinary() + if err != nil { + return nil, err + } + + if uint64(len(blob)) > limit { + return block, nil + } + } +} + func TestInitialStateClean(t *testing.T) { require := require.New(t) genesisDoc, _ := types.GetGenesisWithPrivkey() @@ -109,7 +124,7 @@ func TestIsDAIncluded(t *testing.T) { require.True(m.IsDAIncluded(hash)) } -func TestSubmitBlocks(t *testing.T) { +func TestSubmitBlocksToDA(t *testing.T) { require := require.New(t) ctx := context.Background() @@ -135,24 +150,18 @@ func TestSubmitBlocks(t *testing.T) { blocks: func() []*types.Block { // Find three blocks where two of them are under blob size limit // but adding the third one exceeds the blob size limit - var block1, block2, block3 *types.Block - for numTxs := 0; ; numTxs += 100 { - block1 = types.GetRandomBlock(1, numTxs) - blob1, err := block1.MarshalBinary() - require.NoError(err) - - block2 = types.GetRandomBlock(2, numTxs) - blob2, err := block2.MarshalBinary() - require.NoError(err) - - block3 = types.GetRandomBlock(3, numTxs) - blob3, err := block3.MarshalBinary() - require.NoError(err) - - if uint64(len(blob1)+len(blob2)) < maxDABlobSizeLimit && uint64(len(blob1)+len(blob2)+len(blob3)) > maxDABlobSizeLimit { - return []*types.Block{block1, block2, block3} - } - } + block1 := types.GetRandomBlock(1, 5) + blob1, err := block1.MarshalBinary() + require.NoError(err) + + block2 := types.GetRandomBlock(2, 5) + blob2, err := block2.MarshalBinary() + require.NoError(err) + + block3, err := getBlockBiggerThan(3, maxDABlobSizeLimit-uint64(len(blob1)+len(blob2))) + require.NoError(err) + + return []*types.Block{block1, block2, block3} }(), isErrExpected: false, expectedPendingBlocksLength: 0, @@ -165,16 +174,9 @@ func TestSubmitBlocks(t *testing.T) { for i := 0; i < numBlocks-1; i++ { blocks[i] = types.GetRandomBlock(uint64(i+1), numTxs) } - for numTxs := 0; ; numTxs += 100 { - block3 := types.GetRandomBlock(3, numTxs) - blob3, err := block3.MarshalBinary() - require.NoError(err) - - if uint64(len(blob3)) > maxDABlobSizeLimit { - blocks[2] = block3 - return blocks - } - } + blocks[2], err = getBlockBiggerThan(3, maxDABlobSizeLimit) + require.NoError(err) + return blocks }(), isErrExpected: true, expectedPendingBlocksLength: 1, From 8e42800d25e0d918e93afb297a0fb80a1450f0d8 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 19:25:39 +0400 Subject: [PATCH 22/26] Update numTxs in test case to be 100 --- block/manager_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/block/manager_test.go b/block/manager_test.go index 2f6a2afd3d..5aaff57020 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -150,11 +150,11 @@ func TestSubmitBlocksToDA(t *testing.T) { blocks: func() []*types.Block { // Find three blocks where two of them are under blob size limit // but adding the third one exceeds the blob size limit - block1 := types.GetRandomBlock(1, 5) + block1 := types.GetRandomBlock(1, 100) blob1, err := block1.MarshalBinary() require.NoError(err) - block2 := types.GetRandomBlock(2, 5) + block2 := types.GetRandomBlock(2, 100) blob2, err := block2.MarshalBinary() require.NoError(err) From e4a052f78306cc39cc06a10027f0b0d0fafd5540 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 19:29:51 +0400 Subject: [PATCH 23/26] Fix lint --- block/manager_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/block/manager_test.go b/block/manager_test.go index 5aaff57020..b7db58824d 100644 --- a/block/manager_test.go +++ b/block/manager_test.go @@ -5,10 +5,11 @@ import ( "testing" cmtypes "github.com/cometbft/cometbft/types" - goDATest "github.com/rollkit/go-da/test" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + goDATest "github.com/rollkit/go-da/test" + "github.com/rollkit/rollkit/da" "github.com/rollkit/rollkit/store" test "github.com/rollkit/rollkit/test/log" From 88f8ecf4d9f3468ae9d2abbece13f244ac212133 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 19:56:32 +0400 Subject: [PATCH 24/26] Remove unnecessary casting --- block/manager.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/block/manager.go b/block/manager.go index 228836ddca..5e655f7ba0 100644 --- a/block/manager.go +++ b/block/manager.go @@ -831,8 +831,8 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { backoff := initialBackoff blocksToSubmit := m.pendingBlocks.getPendingBlocks() numTotalBlocks := len(blocksToSubmit) - attempt := uint64(0) - numSubmittedBlocks := uint64(0) + attempt := 0 + numSubmittedBlocks := 0 for ctx.Err() == nil && !submittedAllBlocks && attempt < maxSubmitAttempts { res := m.dalc.SubmitBlocks(ctx, blocksToSubmit) switch res.Code { @@ -842,7 +842,7 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { submittedAllBlocks = true } submittedBlocks, notSubmittedBlocks := blocksToSubmit[:res.SubmittedCount], blocksToSubmit[res.SubmittedCount:] - numSubmittedBlocks += uint64(len(submittedBlocks)) + numSubmittedBlocks += len(submittedBlocks) for _, block := range submittedBlocks { m.blockCache.setDAIncluded(block.Hash().String()) } From 1464c7625a09c5b47dbdbcd3b0f2787366c027f4 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 19:57:58 +0400 Subject: [PATCH 25/26] Switch variable declarations --- block/manager.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/block/manager.go b/block/manager.go index 5e655f7ba0..a6d14bba03 100644 --- a/block/manager.go +++ b/block/manager.go @@ -831,8 +831,8 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { backoff := initialBackoff blocksToSubmit := m.pendingBlocks.getPendingBlocks() numTotalBlocks := len(blocksToSubmit) - attempt := 0 numSubmittedBlocks := 0 + attempt := 0 for ctx.Err() == nil && !submittedAllBlocks && attempt < maxSubmitAttempts { res := m.dalc.SubmitBlocks(ctx, blocksToSubmit) switch res.Code { From 80fd272683070c4adf620b260edd1c011b446f11 Mon Sep 17 00:00:00 2001 From: Manav Aggarwal Date: Thu, 8 Feb 2024 20:07:23 +0400 Subject: [PATCH 26/26] Remove unnecessary case --- block/manager.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/block/manager.go b/block/manager.go index a6d14bba03..1e3c0ee6c1 100644 --- a/block/manager.go +++ b/block/manager.go @@ -848,13 +848,8 @@ func (m *Manager) submitBlocksToDA(ctx context.Context) error { } m.pendingBlocks.removeSubmittedBlocks(submittedBlocks) blocksToSubmit = notSubmittedBlocks - - case da.StatusError, da.StatusNotFound: - m.logger.Error("DA layer submission failed", "error", res.Message, "attempt", attempt) - time.Sleep(backoff) - backoff = m.exponentialBackoff(backoff) default: - m.logger.Error("DA layer unknown status response", "error", res.Message, "attempt", attempt) + m.logger.Error("DA layer submission failed", "error", res.Message, "attempt", attempt) time.Sleep(backoff) backoff = m.exponentialBackoff(backoff) }