fix(celestia): don't wait for DA readiness to start the sequencer (#1337

)
dymensionxyz · Feb 3, 2025 · 60f03aa · 60f03aa
1 parent 5e601a0
commit 60f03aa
Show file tree

Hide file tree

Showing 44 changed files with 1,778 additions and 1,720 deletions.
diff --git a/.mockery.yaml b/.mockery.yaml
@@ -23,9 +23,9 @@ packages:
     interfaces:
       AppConnConsensus:
       AppConns:
-  github.com/dymensionxyz/dymint/da/celestia/types:
+  github.com/dymensionxyz/dymint/da/celestia/client:
     interfaces:
-      CelestiaRPCClient:
+      DAClient:
   github.com/dymensionxyz/dymint/da/avail:
     interfaces:
      SubstrateApiI:

diff --git a/block/manager.go b/block/manager.go
@@ -410,7 +410,7 @@ func (m *Manager) ValidateConfigWithRollappParams() error {
 		return fmt.Errorf("da client mismatch. rollapp param: %s da configured: %s", m.State.RollappParams.Da, m.DAClient.GetClientType())
 	}
 
-	if m.Conf.BatchSubmitBytes > uint64(m.DAClient.GetMaxBlobSizeBytes()) {
+	if m.Conf.BatchSubmitBytes > m.DAClient.GetMaxBlobSizeBytes() {
 		return fmt.Errorf("batch size above limit: batch size: %d limit: %d: DA %s", m.Conf.BatchSubmitBytes, m.DAClient.GetMaxBlobSizeBytes(), m.DAClient.GetClientType())
 	}
 

diff --git a/block/modes.go b/block/modes.go
@@ -43,10 +43,6 @@ func (m *Manager) runAsProposer(ctx context.Context, eg *errgroup.Group) error {
 	// Subscribe to P2P received blocks events (used for P2P syncing).
 	go uevent.MustSubscribe(ctx, m.Pubsub, p2pBlocksyncLoop, p2p.EventQueryNewBlockSyncBlock, m.OnReceivedBlock, m.logger)
 
-	// Sequencer must wait till the DA light client is synced. Otherwise it will fail when submitting blocks.
-	// Full-nodes does not need to wait, but if it tries to fetch blocks from DA heights previous to the DA light client height it will fail, and it will retry till it reaches the height.
-	m.DAClient.WaitForSyncing()
-
 	// Sequencer must wait till node is synced till last submittedHeight, in case it is not
 	m.waitForSettlementSyncing()
 

diff --git a/block/slvalidator_test.go b/block/slvalidator_test.go
@@ -10,7 +10,6 @@ import (
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	tmtypes "github.com/tendermint/tendermint/types"
 
-	"github.com/celestiaorg/celestia-openrpc/types/blob"
 	"github.com/dymensionxyz/dymint/block"
 	"github.com/dymensionxyz/dymint/da"
 	"github.com/dymensionxyz/dymint/p2p"
@@ -304,25 +303,25 @@ func TestStateUpdateValidator_ValidateDAFraud(t *testing.T) {
 	testCases := []struct {
 		name              string
 		checkAvailability bool
-		blobData          []byte
+		blobData          [][]byte
 		expectedErrType   error
 	}{
 		{
 			name:              "Successful DA Blob",
 			checkAvailability: false,
-			blobData:          batchData,
+			blobData:          [][]byte{batchData},
 			expectedErrType:   nil,
 		},
 		{
 			name:              "Blob not valid",
 			checkAvailability: false,
-			blobData:          randomData,
+			blobData:          [][]byte{randomData},
 			expectedErrType:   &types.ErrStateUpdateBlobCorruptedFraud{},
 		},
 		{
 			name:              "Blob unavailable",
 			checkAvailability: true,
-			blobData:          batchData,
+			blobData:          [][]byte{batchData},
 			expectedErrType:   &types.ErrStateUpdateBlobNotAvailableFraud{},
 		},
 	}
@@ -345,32 +344,27 @@ func TestStateUpdateValidator_ValidateDAFraud(t *testing.T) {
 			require.NoError(t, err)
 			manager.Retriever = manager.DAClient.(da.BatchRetriever)
 
-			// Generate blob from batch data
-			require.NoError(t, err)
-			batchBlob, err := blob.NewBlobV0(mockDA.NID, tc.blobData)
-			require.NoError(t, err)
-
 			// RPC calls necessary for blob submission
-			mockDA.MockRPC.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(uint64(1234), nil).Once().Run(func(args mock.Arguments) { time.Sleep(10 * time.Millisecond) })
-			mockDA.MockRPC.On("GetProof", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(&mockDA.BlobProof, nil).Once().Run(func(args mock.Arguments) { time.Sleep(10 * time.Millisecond) })
-			mockDA.MockRPC.On("Included", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(true, nil).Once().Run(func(args mock.Arguments) { time.Sleep(10 * time.Millisecond) })
-			mockDA.MockRPC.On("GetByHeight", mock.Anything, mock.Anything).Return(mockDA.Header, nil).Once().Run(func(args mock.Arguments) { time.Sleep(10 * time.Millisecond) })
+			mockDA.MockRPC.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(mockDA.IDS, nil).Once().Run(func(args mock.Arguments) {})
+			mockDA.MockRPC.On("GetByHeight", mock.Anything, mock.Anything).Return(mockDA.Header, nil).Once().Run(func(args mock.Arguments) { time.Sleep(5 * time.Millisecond) })
+			mockDA.MockRPC.On("GetProofs", mock.Anything, mock.Anything, mock.Anything).Return(mockDA.BlobProofs, nil).Once().Run(func(args mock.Arguments) { time.Sleep(5 * time.Millisecond) })
+			mockDA.MockRPC.On("Validate", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return([]bool{true}, nil).Once().Run(func(args mock.Arguments) { time.Sleep(5 * time.Millisecond) })
 
 			// Submit batch to DA
 			daResultSubmitBatch := manager.DAClient.SubmitBatch(batch)
 			assert.Equal(t, daResultSubmitBatch.Code, da.StatusSuccess)
 
 			// RPC calls for successful blob retrieval
 			if !tc.checkAvailability {
-				mockDA.MockRPC.On("Get", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(batchBlob, nil).Run(func(args mock.Arguments) {})
+				mockDA.MockRPC.On("Get", mock.Anything, mock.Anything, mock.Anything).Return(tc.blobData, nil).Run(func(args mock.Arguments) { time.Sleep(5 * time.Millisecond) })
 			}
 
 			// RPC calls for unavailable blobs
 			if tc.checkAvailability {
-				mockDA.MockRPC.On("Get", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil).Run(func(args mock.Arguments) {})
-				mockDA.MockRPC.On("GetProof", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(&mockDA.BlobProof, nil).Once().Run(func(args mock.Arguments) { time.Sleep(10 * time.Millisecond) })
-				mockDA.MockRPC.On("Included", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(false, nil).Once().Run(func(args mock.Arguments) { time.Sleep(10 * time.Millisecond) })
-				mockDA.MockRPC.On("GetByHeight", mock.Anything, mock.Anything).Return(mockDA.Header, nil).Once().Run(func(args mock.Arguments) { time.Sleep(10 * time.Millisecond) })
+				mockDA.MockRPC.On("Get", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil).Run(func(args mock.Arguments) { time.Sleep(5 * time.Millisecond) })
+				mockDA.MockRPC.On("GetByHeight", mock.Anything, mock.Anything).Return(mockDA.Header, nil).Once().Run(func(args mock.Arguments) { time.Sleep(5 * time.Millisecond) })
+				mockDA.MockRPC.On("GetProofs", mock.Anything, mock.Anything, mock.Anything).Return(mockDA.BlobProofs, nil).Once().Run(func(args mock.Arguments) { time.Sleep(5 * time.Millisecond) })
+				mockDA.MockRPC.On("Validate", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return([]bool{false}, nil).Once().Run(func(args mock.Arguments) { time.Sleep(5 * time.Millisecond) })
 			}
 
 			// Create the StateUpdateValidator

diff --git a/da/avail/avail.go b/da/avail/avail.go
@@ -163,11 +163,6 @@ func (c *DataAvailabilityLayerClient) Stop() error {
 	return nil
 }
 
-// WaitForSyncing is used to check when the DA light client finished syncing
-func (m *DataAvailabilityLayerClient) WaitForSyncing() {
-	<-m.synced
-}
-
 // GetClientType returns client type.
 func (c *DataAvailabilityLayerClient) GetClientType() da.Client {
 	return da.Avail
@@ -450,7 +445,7 @@ func (c *DataAvailabilityLayerClient) getHeightFromHash(hash availtypes.Hash) (u
 }
 
 // GetMaxBlobSizeBytes returns the maximum allowed blob size in the DA, used to check the max batch size configured
-func (d *DataAvailabilityLayerClient) GetMaxBlobSizeBytes() uint32 {
+func (d *DataAvailabilityLayerClient) GetMaxBlobSizeBytes() uint64 {
 	return maxBlobSize
 }