feat: reorg handling

cwclient/cwclient.go

@@ -95,6 +95,44 @@ func (cwClient *CosmWasmClient) QueryIsEnabled() (bool, error) {
 	return isEnabled, nil
 }
 
+func (cwClient *CosmWasmClient) QueryIsBlockForked(blockHeight uint64) (bool, error) {
+	queryData, err := createIsForkedBlockQueryData(blockHeight)
+	if err != nil {
+		return false, err
+	}
+
+	resp, err := cwClient.querySmartContractState(queryData)
+	if err != nil {
+		return false, err
+	}
+
+	var isForked bool
+	if err := json.Unmarshal(resp.Data, &isForked); err != nil {
+		return false, err
+	}
+
+	return isForked, nil
+}
+
+func (cwClient *CosmWasmClient) QueryForkedBlocksInRange(startHeight, endHeight uint64) ([]blockRange, error) {
+	queryData, err := createForkedBlocksInRangeQueryData(startHeight, endHeight)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := cwClient.querySmartContractState(queryData)
+	if err != nil {
+		return nil, err
+	}
+
+	var forkedBlocks []blockRange
+	if err := json.Unmarshal(resp.Data, &forkedBlocks); err != nil {
+		return nil, err
+	}
+
+	return forkedBlocks, nil
+}
+
 //////////////////////////////
 // INTERNAL
 //////////////////////////////
@@ -118,16 +156,27 @@ type contractConfigResponse struct {
 	ActivatedHeight uint64 `json:"activated_height"`
 }
 type ContractQueryMsgs struct {
-	Config      *contractConfig   `json:"config,omitempty"`
-	BlockVoters *blockVotersQuery `json:"block_voters,omitempty"`
-	IsEnabled   *isEnabledQuery   `json:"is_enabled,omitempty"`
+	Config              *contractConfig     `json:"config,omitempty"`
+	BlockVoters         *blockVotersQuery   `json:"block_voters,omitempty"`
+	IsBlockForked       *isBlockForkedQuery `json:"is_block_forked,omitempty"`
+	ForkedBlocksInRange *blockRange         `json:"forked_blocks_in_range,omitempty"`
+	IsEnabled           *isEnabledQuery     `json:"is_enabled,omitempty"`
+}
+
+type blockRange struct {
+	Start uint64 `json:"start"`
+	End   uint64 `json:"end"`
 }
 
 type blockVotersQuery struct {
 	Hash   string `json:"hash"`
 	Height uint64 `json:"height"`
 }
 
+type isBlockForkedQuery struct {
+	Height uint64 `json:"height"`
+}
+
 type isEnabledQuery struct{}
 
 type contractConfig struct{}
@@ -154,6 +203,33 @@ func createIsEnabledQueryData() ([]byte, error) {
 	return data, nil
 }
 
+func createIsForkedBlockQueryData(blockHeight uint64) ([]byte, error) {
+	queryData := ContractQueryMsgs{
+		IsBlockForked: &isBlockForkedQuery{
+			Height: blockHeight,
+		},
+	}
+	data, err := json.Marshal(queryData)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+func createForkedBlocksInRangeQueryData(startHeight, endHeight uint64) ([]byte, error) {
+	queryData := ContractQueryMsgs{
+		ForkedBlocksInRange: &blockRange{
+			Start: startHeight,
+			End:   endHeight,
+		},
+	}
+	data, err := json.Marshal(queryData)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
 // querySmartContractState queries the smart contract state given the contract address and query data
 func (cwClient *CosmWasmClient) querySmartContractState(
 	queryData []byte,

finalitygadget/expected_clients.go

@@ -28,6 +28,7 @@ type IBabylonClient interface {
 type ICosmWasmClient interface {
 	QueryListOfVotedFinalityProviders(queryParams *types.Block) ([]string, error)
 	QueryConsumerId() (string, error)
+	QueryIsBlockForked(blockHeight uint64) (bool, error)
 	QueryIsEnabled() (bool, error)
 }
 

finalitygadget/finalitygadget.go

@@ -150,6 +150,15 @@ func (fg *FinalityGadget) QueryIsBlockBabylonFinalizedFromBabylon(block *types.B
 		return true, nil
 	}
 
+	// check if block is part of reorg whitelist, if so return true to unblock deriv pipeline
+	isForked, err := fg.cwClient.QueryIsBlockForked(block.BlockHeight)
+	if err != nil {
+		return false, err
+	}
+	if isForked {
+		return true, nil
+	}
+
 	// trim prefix 0x for the L2 block hash
 	block.BlockHash = strings.TrimPrefix(block.BlockHash, "0x")
 

finalitygadget/finalitygadget_test.go

@@ -150,6 +150,7 @@ func TestQueryIsBlockBabylonFinalized(t *testing.T) {
 
 			mockCwClient := mocks.NewMockICosmWasmClient(ctl)
 			mockCwClient.EXPECT().QueryIsEnabled().Return(true, nil).Times(1)
+			mockCwClient.EXPECT().QueryIsBlockForked(tc.block.BlockHeight).Return(false, nil).Times(1)
 			mockCwClient.EXPECT().QueryConsumerId().Return(consumerChainID, nil).Times(1)
 			mockBTCClient := mocks.NewMockIBitcoinClient(ctl)
 			mockBTCClient.EXPECT().
@@ -268,8 +269,9 @@ func TestQueryBlockRangeBabylonFinalized(t *testing.T) {
 			defer ctl.Finish()
 
 			mockDbHandler := mocks.NewMockIDatabaseHandler(ctl)
+			mockCwClient := mocks.NewMockICosmWasmClient(ctl)
 
-			// Setup mock DB responses
+			// Setup mock DB and cw contract responses
 			if len(tc.queryBlocks) > 0 && tc.queryDB {
 				mockDbHandler.EXPECT().
 					QueryEarliestFinalizedBlock().
@@ -282,7 +284,8 @@ func TestQueryBlockRangeBabylonFinalized(t *testing.T) {
 			}
 
 			mockFinalityGadget := &FinalityGadget{
-				db: mockDbHandler,
+				db:       mockDbHandler,
+				cwClient: mockCwClient,
 			}
 
 			res, err := mockFinalityGadget.QueryBlockRangeBabylonFinalized(tc.queryBlocks)
@@ -668,6 +671,29 @@ func TestQueryIsBlockFinalizedByHashForNonExistentBlock(t *testing.T) {
 	require.Equal(t, err, types.ErrBlockNotFound)
 }
 
+func TestQueryIsBlockFinalizedFromBabylonForked(t *testing.T) {
+	ctl := gomock.NewController(t)
+
+	// mock CwClient
+	mockCwClient := mocks.NewMockICosmWasmClient(ctl)
+	mockCwClient.EXPECT().QueryIsEnabled().Return(true, nil).Times(1)
+	mockCwClient.EXPECT().QueryIsBlockForked(uint64(1)).Return(true, nil).Times(1)
+
+	mockTestFinalityGadget := &FinalityGadget{
+		cwClient:  mockCwClient,
+		bbnClient: nil,
+		btcClient: nil,
+	}
+
+	res, err := mockTestFinalityGadget.QueryIsBlockBabylonFinalizedFromBabylon(&types.Block{
+		BlockHeight:    1,
+		BlockHash:      "0x123",
+		BlockTimestamp: 1000,
+	})
+	require.NoError(t, err)
+	require.True(t, res)
+}
+
 func TestQueryLatestFinalizedBlock(t *testing.T) {
 	// define blocks
 	first := &types.Block{