chore(relayer): fix correct order of dest/src (#21154)

Author: MatusKysel

packages/relayer/pkg/mock/event_repository.go

@@ -15,7 +15,29 @@ import (
 )
 
 type EventRepository struct {
-	events []*relayer.Event
+	events                                         []*relayer.Event
+	ChainDataSyncedEventByBlockNumberOrGreaterFunc func(
+		ctx context.Context,
+		srcChainId uint64,
+		syncedChainId uint64,
+		blockNumber uint64,
+	) (*relayer.Event, error)
+	LatestChainDataSyncedEventFunc func(
+		ctx context.Context,
+		srcChainId uint64,
+		syncedChainId uint64,
+	) (uint64, error)
+	CheckpointSyncedEventByBlockNumberOrGreaterFunc func(
+		ctx context.Context,
+		chainId uint64,
+		syncedChainId uint64,
+		blockNumber uint64,
+	) (*relayer.Event, error)
+	LatestCheckpointSyncedEventFunc func(
+		ctx context.Context,
+		chainId uint64,
+		syncedChainId uint64,
+	) (uint64, error)
 }
 
 func NewEventRepository() *EventRepository {
@@ -190,6 +212,10 @@ func (r *EventRepository) ChainDataSyncedEventByBlockNumberOrGreater(
 	syncedChainId uint64,
 	blockNumber uint64,
 ) (*relayer.Event, error) {
+	if r.ChainDataSyncedEventByBlockNumberOrGreaterFunc != nil {
+		return r.ChainDataSyncedEventByBlockNumberOrGreaterFunc(ctx, srcChainId, syncedChainId, blockNumber)
+	}
+
 	return &relayer.Event{
 		ID:      rand.Int(), // nolint: gosec
 		ChainID: MockChainID.Int64(),
@@ -201,6 +227,10 @@ func (r *EventRepository) LatestChainDataSyncedEvent(
 	srcChainId uint64,
 	syncedChainId uint64,
 ) (uint64, error) {
+	if r.LatestChainDataSyncedEventFunc != nil {
+		return r.LatestChainDataSyncedEventFunc(ctx, srcChainId, syncedChainId)
+	}
+
 	return 5, nil
 }
 
@@ -210,6 +240,10 @@ func (r *EventRepository) CheckpointSyncedEventByBlockNumberOrGreater(
 	syncedChainId uint64,
 	blockNumber uint64,
 ) (*relayer.Event, error) {
+	if r.CheckpointSyncedEventByBlockNumberOrGreaterFunc != nil {
+		return r.CheckpointSyncedEventByBlockNumberOrGreaterFunc(ctx, chainId, syncedChainId, blockNumber)
+	}
+
 	return &relayer.Event{
 		ID:      rand.Int(), // nolint: gosec
 		ChainID: MockChainID.Int64(),
@@ -221,6 +255,10 @@ func (r *EventRepository) LatestCheckpointSyncedEvent(
 	chainId uint64,
 	syncedChainId uint64,
 ) (uint64, error) {
+	if r.LatestCheckpointSyncedEventFunc != nil {
+		return r.LatestCheckpointSyncedEventFunc(ctx, chainId, syncedChainId)
+	}
+
 	return 5, nil
 }
 

packages/relayer/processor/process_message.go

@@ -337,7 +337,7 @@ func (p *Processor) generateEncodedSignalProof(ctx context.Context,
 	// we can grab the latestBlockID, create a singular "hop" of srcChain => destChain,
 	// and generate a proof.
 	if len(p.hops) == 0 {
-		latestBlockID, err := p.latestSyncedBlockID(ctx, p.srcChainId.Uint64(), p.destChainId.Uint64())
+		latestBlockID, err := p.latestSyncedBlockID(ctx, p.destChainId.Uint64(), p.srcChainId.Uint64())
 		if err != nil {
 			return nil, err
 		}

packages/relayer/processor/process_message_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/taikoxyz/taiko-mono/packages/relayer"
 	"github.com/taikoxyz/taiko-mono/packages/relayer/bindings/bridge"
 	"github.com/taikoxyz/taiko-mono/packages/relayer/pkg/mock"
+	"github.com/taikoxyz/taiko-mono/packages/relayer/pkg/proof"
 	"github.com/taikoxyz/taiko-mono/packages/relayer/pkg/queue"
 )
 
@@ -319,3 +320,70 @@ func Test_ProcessMessage_continuesOutsideShastaForkWindow(t *testing.T) {
 	assert.Nil(t, err)
 	assert.True(t, shouldRequeue)
 }
+
+func TestGenerateEncodedSignalProofUsesDestChainCheckpoint(t *testing.T) {
+	const (
+		srcChainID  = uint64(1)
+		destChainID = uint64(2)
+	)
+
+	repo := mock.NewEventRepository()
+	repo.LatestChainDataSyncedEventFunc = func(
+		ctx context.Context,
+		chainID uint64,
+		syncedChainID uint64,
+	) (uint64, error) {
+		if chainID != destChainID || syncedChainID != srcChainID {
+			return 0, errors.New("unexpected chain IDs")
+		}
+
+		return 1, nil
+	}
+	repo.LatestCheckpointSyncedEventFunc = func(
+		ctx context.Context,
+		chainID uint64,
+		syncedChainID uint64,
+	) (uint64, error) {
+		if chainID != destChainID || syncedChainID != srcChainID {
+			return 0, errors.New("unexpected chain IDs")
+		}
+
+		return 10, nil
+	}
+
+	ethClient := &mock.EthClient{}
+	prover, err := proof.New(ethClient, 0)
+	assert.Nil(t, err)
+
+	p := &Processor{
+		eventRepo:               repo,
+		srcChainId:              big.NewInt(int64(srcChainID)),
+		destChainId:             big.NewInt(int64(destChainID)),
+		srcEthClient:            ethClient,
+		srcCaller:               &mock.Caller{},
+		prover:                  prover,
+		srcSignalService:        &mock.SignalService{},
+		srcSignalServiceAddress: common.HexToAddress("0x0000000000000000000000000000000000000001"),
+		ethClientTimeout:        time.Second,
+	}
+
+	event := &bridge.BridgeMessageSent{
+		MsgHash: [32]byte{0x01},
+		Message: bridge.IBridgeMessage{
+			SrcChainId:  srcChainID,
+			DestChainId: destChainID,
+			From:        common.HexToAddress("0x0000000000000000000000000000000000000002"),
+			SrcOwner:    common.HexToAddress("0x0000000000000000000000000000000000000002"),
+			DestOwner:   common.HexToAddress("0x0000000000000000000000000000000000000002"),
+			To:          common.HexToAddress("0x0000000000000000000000000000000000000002"),
+			GasLimit:    1,
+		},
+		Raw: types.Log{
+			Address:     common.HexToAddress("0x0000000000000000000000000000000000000003"),
+			BlockNumber: 1,
+		},
+	}
+
+	_, err = p.generateEncodedSignalProof(context.Background(), event)
+	assert.Nil(t, err)
+}