add move sync

Author: zhouop0

build/dispute-explorer

@@ -82,6 +82,7 @@ func (h *FrontendMoveHandler) RecordFrontendMove(req *FrontendMoveRequest) error
 		DisputedClaim:  req.DisputedClaim,
 		Status:         schema.FrontendMoveStatusPending,
 		SubmittedAt:    time.Now().Unix(),
+		IsSynced:       false, // 新记录默认未同步
 	}
 
 	// Save to database

internal/handler/frontend_move.go

@@ -25,6 +25,8 @@ func Run(ctx *svc.ServiceContext) {
 	go CalculateLostBond(ctx)
 	// sync claim len
 	go SyncClaimDataLen(ctx)
+	// sync frontend move transactions
+	go SyncFrontendMoveTransactions(ctx)
 }
 
 // startRPCMonitoring starts RPC monitoring (internal function)

internal/handler/handler.go

@@ -0,0 +1,99 @@
+package handler
+
+import (
+	"time"
+
+	"github.com/optimism-java/dispute-explorer/internal/schema"
+	"github.com/optimism-java/dispute-explorer/internal/svc"
+	"github.com/optimism-java/dispute-explorer/pkg/log"
+)
+
+func SyncFrontendMoveTransactions(ctx *svc.ServiceContext) {
+	log.Infof("[Handler.SyncFrontendMoveTransactions] Starting sync frontend move transactions...")
+
+	for {
+		select {
+		case <-ctx.Context.Done():
+			log.Infof("[Handler.SyncFrontendMoveTransactions] Context cancelled, stopping...")
+			return
+		default:
+			err := processFrontendMoveTransactions(ctx)
+			if err != nil {
+				log.Errorf("[Handler.SyncFrontendMoveTransactions] Process error: %s", err)
+			}
+			time.Sleep(30 * time.Second)
+		}
+	}
+}
+
+// processFrontendMoveTransactions
+func processFrontendMoveTransactions(ctx *svc.ServiceContext) error {
+	var unsyncedTransactions []schema.FrontendMoveTransaction
+	err := ctx.DB.Where("is_synced = ?", false).Order("id").Limit(10).Find(&unsyncedTransactions).Error
+	if err != nil {
+		return err
+	}
+
+	if len(unsyncedTransactions) == 0 {
+		log.Debugf("[Handler.SyncFrontendMoveTransactions] No unsynced transactions found")
+		return nil
+	}
+
+	log.Infof("[Handler.SyncFrontendMoveTransactions] Found %d unsynced transactions", len(unsyncedTransactions))
+
+	for _, transaction := range unsyncedTransactions {
+		err := syncSingleTransaction(ctx, &transaction)
+		if err != nil {
+			log.Errorf("[Handler.SyncFrontendMoveTransactions] Failed to sync transaction %s: %s", transaction.TxHash, err)
+			continue
+		}
+	}
+
+	return nil
+}
+
+// syncSingleTransaction
+func syncSingleTransaction(ctx *svc.ServiceContext, transaction *schema.FrontendMoveTransaction) error {
+	tx := ctx.DB.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// 1. update dispute_game has_frontend_move column to true
+	err := tx.Model(&schema.DisputeGame{}).
+		Where("game_contract = ?", transaction.GameContract).
+		Update("has_frontend_move", true).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	// 2. update game_claim_data is_from_frontend column to true
+	err = tx.Model(&schema.GameClaimData{}).
+		Where("game_contract = ? AND parent_index = ?", transaction.GameContract, transaction.ParentIndex).
+		Update("is_from_frontend", true).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	// 3. update frontend_move_transactions is_synced column to true
+	err = tx.Model(transaction).Update("is_synced", true).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	// tx commit
+	err = tx.Commit().Error
+	if err != nil {
+		return err
+	}
+
+	log.Infof("[Handler.SyncFrontendMoveTransactions] Successfully synced transaction %s (game: %s, parent_index: %s)",
+		transaction.TxHash, transaction.GameContract, transaction.ParentIndex)
+
+	return nil
+}

internal/handler/syncFrontendMove.go

@@ -22,6 +22,7 @@ type FrontendMoveTransaction struct {
 	ErrorMessage   string `json:"error_message,omitempty"`                                  // Error message (if any)
 	SubmittedAt    int64  `json:"submitted_at"`                                             // Submission timestamp
 	ConfirmedAt    int64  `json:"confirmed_at,omitempty"`                                   // Confirmation timestamp
+	IsSynced       bool   `json:"is_synced" gorm:"default:false;index:idx_is_synced"`       // Whether synced to related tables
 }
 
 func (FrontendMoveTransaction) TableName() string {

internal/schema/frontend_move_transaction.go

@@ -10,6 +10,7 @@ import (
 	v6 "github.com/optimism-java/dispute-explorer/migration/version/v6"
 	v7 "github.com/optimism-java/dispute-explorer/migration/version/v7"
 	v8 "github.com/optimism-java/dispute-explorer/migration/version/v8"
+	v9 "github.com/optimism-java/dispute-explorer/migration/version/v9"
 )
 
 var ModelSchemaList = []*gormigrate.Migration{
@@ -21,4 +22,5 @@ var ModelSchemaList = []*gormigrate.Migration{
 	&v6.UpdateClaimDataClockColumnTable,
 	&v7.AddClaimDataLenForDisputeGameTable,
 	&v8.AddFrontendMoveTrackingTable,
+	&v9.AddIsSyncedFieldTable,
 }

migration/version/migration_version.go

@@ -0,0 +1,32 @@
+package v9
+
+import (
+	"fmt"
+
+	gormigrate "github.com/go-gormigrate/gormigrate/v2"
+	"github.com/optimism-java/dispute-explorer/internal/schema"
+	"gorm.io/gorm"
+)
+
+var AddIsSyncedFieldTable = gormigrate.Migration{
+	ID:      "20240829_add_is_synced_field",
+	Migrate: AddIsSyncedToFrontendMoveTransactions,
+}
+
+func AddIsSyncedToFrontendMoveTransactions(db *gorm.DB) error {
+	// Check and add is_synced field to frontend_move_transactions table
+	if !db.Migrator().HasColumn(&schema.FrontendMoveTransaction{}, "is_synced") {
+		err := db.Migrator().AddColumn(&schema.FrontendMoveTransaction{}, "is_synced")
+		if err != nil {
+			return fmt.Errorf("failed to add is_synced column to frontend_move_transactions: %v", err)
+		}
+
+		// Set default value for newly added field
+		err = db.Model(&schema.FrontendMoveTransaction{}).Update("is_synced", false).Error
+		if err != nil {
+			return fmt.Errorf("failed to set default value for is_synced: %v", err)
+		}
+	}
+
+	return nil
+}