test: add tests

Author: julienrbrt

sequencers/based/sequencer.go

@@ -133,8 +133,10 @@ func (s *BasedSequencer) GetNextBatch(ctx context.Context, req coresequencer.Get
 	}
 
 	return &coresequencer.GetNextBatchResponse{
-		Batch:     batch,
-		Timestamp: t,
+		Batch: batch,
+		// timestamp correspond to the last block time of a DA epoch, based on the remaining transactions to be executed
+		// this is done in order to handle the case where a DA epoch must fit in multiple blocks
+		Timestamp: t.Add(-time.Duration(len(batch.Transactions)) * time.Millisecond),
 		BatchData: req.LastBatchData,
 	}, nil
 }

sequencers/based/sequencer_test.go

@@ -3,6 +3,7 @@ package based
 import (
 	"context"
 	"testing"
+	"time"
 
 	ds "github.com/ipfs/go-datastore"
 	syncds "github.com/ipfs/go-datastore/sync"
@@ -539,3 +540,143 @@ func TestBasedSequencer_GetNextBatch_EmptyDABatch_IncreasesDAHeight(t *testing.T
 
 	mockRetriever.AssertExpectations(t)
 }
+
+func TestBasedSequencer_GetNextBatch_TimestampAdjustment(t *testing.T) {
+	// Test that timestamp is adjusted based on the number of transactions in the batch
+	// The timestamp should be: daEndTime - (len(batch.Transactions) * 1ms)
+
+	testBlobs := [][]byte{[]byte("tx1"), []byte("tx2"), []byte("tx3")}
+	daEndTime := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)
+
+	mockRetriever := new(MockForcedInclusionRetriever)
+	mockRetriever.On("RetrieveForcedIncludedTxs", mock.Anything, uint64(100)).Return(&block.ForcedInclusionEvent{
+		Txs:           testBlobs,
+		StartDaHeight: 100,
+		EndDaHeight:   100,
+		Timestamp:     daEndTime,
+	}, nil)
+
+	gen := genesis.Genesis{
+		ChainID:                "test-chain",
+		DAStartHeight:          100,
+		DAEpochForcedInclusion: 1,
+	}
+
+	seq := createTestSequencer(t, mockRetriever, gen)
+
+	req := coresequencer.GetNextBatchRequest{
+		MaxBytes:      1000000,
+		LastBatchData: nil,
+	}
+
+	resp, err := seq.GetNextBatch(context.Background(), req)
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.NotNil(t, resp.Batch)
+	assert.Equal(t, 3, len(resp.Batch.Transactions))
+
+	// Timestamp should be adjusted by subtracting 3ms (one per transaction)
+	expectedTimestamp := daEndTime.Add(-3 * time.Millisecond)
+	assert.Equal(t, expectedTimestamp, resp.Timestamp)
+
+	mockRetriever.AssertExpectations(t)
+}
+
+func TestBasedSequencer_GetNextBatch_TimestampAdjustment_PartialBatch(t *testing.T) {
+	// Test timestamp adjustment when MaxBytes limits the batch size
+	tx1 := make([]byte, 100)
+	tx2 := make([]byte, 150)
+	tx3 := make([]byte, 200)
+	testBlobs := [][]byte{tx1, tx2, tx3}
+	daEndTime := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)
+
+	mockRetriever := new(MockForcedInclusionRetriever)
+	mockRetriever.On("RetrieveForcedIncludedTxs", mock.Anything, uint64(100)).Return(&block.ForcedInclusionEvent{
+		Txs:           testBlobs,
+		StartDaHeight: 100,
+		EndDaHeight:   100,
+		Timestamp:     daEndTime,
+	}, nil)
+
+	gen := genesis.Genesis{
+		ChainID:                "test-chain",
+		DAStartHeight:          100,
+		DAEpochForcedInclusion: 1,
+	}
+
+	seq := createTestSequencer(t, mockRetriever, gen)
+
+	// First call with MaxBytes that fits only first 2 transactions
+	req := coresequencer.GetNextBatchRequest{
+		MaxBytes:      250,
+		LastBatchData: nil,
+	}
+
+	resp, err := seq.GetNextBatch(context.Background(), req)
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.NotNil(t, resp.Batch)
+	assert.Equal(t, 2, len(resp.Batch.Transactions))
+
+	// Timestamp should be adjusted by subtracting 2ms (for 2 transactions)
+	expectedTimestamp := daEndTime.Add(-2 * time.Millisecond)
+	assert.Equal(t, expectedTimestamp, resp.Timestamp)
+
+	// Second call should get the remaining transaction
+	req = coresequencer.GetNextBatchRequest{
+		MaxBytes:      1000,
+		LastBatchData: nil,
+	}
+
+	// The timestamp for the second call should still have adjustment applieds
+	resp, err = seq.GetNextBatch(context.Background(), req)
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.NotNil(t, resp.Batch)
+	assert.Equal(t, 1, len(resp.Batch.Transactions))
+
+	// Timestamp should be zero time with 1ms subtracted (which is still effectively zero but negative)
+	// When t is zero time, t.Add(-1ms) results in a time before the zero time
+	expectedTimestamp2 := daEndTime.Add(-1 * time.Millisecond)
+	assert.Equal(t, expectedTimestamp2, resp.Timestamp)
+
+	mockRetriever.AssertExpectations(t)
+}
+
+func TestBasedSequencer_GetNextBatch_TimestampAdjustment_EmptyBatch(t *testing.T) {
+	// Test that timestamp is zero when batch is empty
+	daEndTime := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)
+
+	mockRetriever := new(MockForcedInclusionRetriever)
+	mockRetriever.On("RetrieveForcedIncludedTxs", mock.Anything, uint64(100)).Return(&block.ForcedInclusionEvent{
+		Txs:           [][]byte{},
+		StartDaHeight: 100,
+		EndDaHeight:   100,
+		Timestamp:     daEndTime,
+	}, nil)
+
+	gen := genesis.Genesis{
+		ChainID:                "test-chain",
+		DAStartHeight:          100,
+		DAEpochForcedInclusion: 1,
+	}
+
+	seq := createTestSequencer(t, mockRetriever, gen)
+
+	req := coresequencer.GetNextBatchRequest{
+		MaxBytes:      1000000,
+		LastBatchData: nil,
+	}
+
+	resp, err := seq.GetNextBatch(context.Background(), req)
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.NotNil(t, resp.Batch)
+	assert.Equal(t, 0, len(resp.Batch.Transactions))
+
+	// When batch is empty, timestamp adjustment should still be applied (subtract 0ms)
+	expectedTimestamp := daEndTime.Add(-0 * time.Millisecond)
+	assert.Equal(t, expectedTimestamp, resp.Timestamp)
+
+	mockRetriever.AssertExpectations(t)
+}