merge develop 1.1.0

.github/workflows/ci.yml

@@ -5,9 +5,9 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Install Go
-        uses: actions/setup-go@v1
+        uses: actions/setup-go@v5
         with:
           go-version: 1.21
       - name: "Build binaries"
@@ -17,4 +17,4 @@ jobs:
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v1
         with:
-          file: ./cover.out
+          file: ./cover.out

.github/workflows/lint.yml

@@ -5,11 +5,11 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Install Go
-        uses: actions/setup-go@v1
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.17
+          go-version: 1.21
       - name: "Run lint"
         uses: golangci/golangci-lint-action@v3
         with:

README.md

@@ -7,7 +7,7 @@ Validator node for Bittorrent Chain Network. It uses peppermint, customized [Ten
 
 ### Install from source 
 
-Make sure your have go1.11+ already installed
+Make sure your have go1.21+ already installed
 
 ### Install 
 ```bash 

auth/querier_test.go

@@ -157,11 +157,19 @@ func (suite *QuerierTestSuite) TestQueryParams() {
 	require.Equal(t, uint64(8), params.TxSizeCostPerByte)
 
 	{
+		// When params are not set, querier should return zero values instead of panicking
 		happ := app.Setup(true)
 		ctx := happ.BaseApp.NewContext(true, abci.Header{})
 		querier := auth.NewQuerier(happ.AccountKeeper)
-		require.Panics(t, func() {
-			querier(ctx, path, req)
-		})
+		res, err = querier(ctx, path, req)
+		require.NoError(t, err)
+		require.NotNil(t, res)
+
+		var zeroParams types.Params
+		err4 := json.Unmarshal(res, &zeroParams)
+		require.NoError(t, err4)
+		// Params should be zero values when not initialized
+		require.Equal(t, uint64(0), zeroParams.MaxMemoCharacters)
+		require.Equal(t, uint64(0), zeroParams.TxSigLimit)
 	}
 }

bridge/setu/broadcaster/broadcaster.go

@@ -120,7 +120,7 @@ func (tb *TxBroadcaster) BroadcastToMatic(msg bor.CallMsg) error {
 	maticClient := helper.GetMaticClient()
 
 	// get auth
-	auth, err := helper.GenerateAuthObj(maticClient, *msg.To, msg.Data)
+	auth, err := helper.GenerateAuthObj(maticClient, *msg.To, msg.Data, false)
 
 	if err != nil {
 		tb.logger.Error("Error generating auth object", "error", err)

bridge/setu/listener/heimdall.go

@@ -3,6 +3,7 @@ package listener
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"math/big"
 	"strconv"
 	"sync"
@@ -16,7 +17,6 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	checkpointTypes "github.com/maticnetwork/heimdall/checkpoint/types"
 	clerkTypes "github.com/maticnetwork/heimdall/clerk/types"
-	featureManagerTypes "github.com/maticnetwork/heimdall/featuremanager/types"
 	slashingTypes "github.com/maticnetwork/heimdall/slashing/types"
 	stakingTypes "github.com/maticnetwork/heimdall/staking/types"
 	htype "github.com/maticnetwork/heimdall/types"
@@ -48,8 +48,17 @@ func (hl *HeimdallListener) Start() error {
 
 	// Heimdall pollIntervall = (minimal pollInterval of rootchain and matichain)
 	pollInterval := helper.GetConfig().EthSyncerPollInterval
-	if helper.GetConfig().CheckpointerPollInterval < helper.GetConfig().EthSyncerPollInterval {
-		pollInterval = helper.GetConfig().CheckpointerPollInterval
+
+	checkpointPollInterval := helper.GetConfig().CheckpointerPollInterval
+
+	// fetch initial checkpoint params (will retry up to 10 times or exit service)
+	checkpointParams := util.GetCheckpointParamsWithRetry(hl.cliCtx)
+	if checkpointParams.CheckpointPollInterval > 0 {
+		checkpointPollInterval = checkpointParams.CheckpointPollInterval
+	}
+
+	if checkpointPollInterval < helper.GetConfig().EthSyncerPollInterval {
+		pollInterval = checkpointPollInterval
 	}
 
 	hl.Logger.Info("Start polling for events", "pollInterval", pollInterval)
@@ -104,14 +113,17 @@ func (hl *HeimdallListener) StartPolling(ctx context.Context, pollInterval time.
 
 				hl.Logger.Info("Fetching new events between", "fromBlock", fromBlock, "toBlock", toBlock)
 
+				// set to avoid deduplicate checkpoint-sync events by (rootChain, number, startBlock, endBlock)
+				checkpointSyncSet := make(map[string]struct{})
+
 				// Querying and processing Begin events
 				for i := fromBlock; i <= toBlock; i++ {
 					events, err := helper.GetBeginBlockEvents(hl.httpClient, int64(i))
 					if err != nil {
 						hl.Logger.Error("Error fetching begin block events", "error", err)
 					}
 					for _, event := range events {
-						hl.ProcessBlockEvent(sdk.StringifyEvent(event), int64(i))
+						hl.ProcessBlockEvent(sdk.StringifyEvent(event), int64(i), checkpointSyncSet)
 					}
 				}
 
@@ -194,11 +206,18 @@ func (hl *HeimdallListener) fetchFromAndToBlock() (uint64, uint64, error) {
 			return fromBlock, toBlock, err
 		}
 	}
+	maxQueryBlocks := helper.GetConfig().HeimdallMaxQueryBlocks
+	if maxQueryBlocks == 0 {
+		maxQueryBlocks = helper.DefaultHeimdallMaxQueryBlocks
+	}
+	if maxQueryBlocks != 0 && toBlock-fromBlock > uint64(maxQueryBlocks) {
+		toBlock = fromBlock + uint64(maxQueryBlocks)
+	}
 	return fromBlock, toBlock, err
 }
 
 // ProcessBlockEvent - process Blockevents (BeginBlock, EndBlock events) from heimdall.
-func (hl *HeimdallListener) ProcessBlockEvent(event sdk.StringEvent, blockHeight int64) {
+func (hl *HeimdallListener) ProcessBlockEvent(event sdk.StringEvent, blockHeight int64, checkpointSyncSet map[string]struct{}) {
 	hl.Logger.Info("Received block event from Heimdall", "eventType", event.Type, "height", blockHeight)
 	eventBytes, err := json.Marshal(event)
 	if err != nil {
@@ -210,6 +229,13 @@ func (hl *HeimdallListener) ProcessBlockEvent(event sdk.StringEvent, blockHeight
 	case checkpointTypes.EventTypeCheckpoint:
 		hl.sendBlockTask("sendCheckpointToRootchain", eventBytes, blockHeight)
 	case checkpointTypes.EventTypeCheckpointSync:
+		key := hl.getCheckpointSyncKey(event)
+		if _, exists := checkpointSyncSet[key]; exists {
+			hl.Logger.Info("CheckpointSync duplicate, skip sending task", "key", key)
+			return
+		}
+
+		checkpointSyncSet[key] = struct{}{}
 		hl.sendBlockTask("sendCheckpointSyncToStakeChain", eventBytes, blockHeight)
 	case slashingTypes.EventTypeSlashLimit:
 		hl.sendBlockTask("sendTickToHeimdall", eventBytes, blockHeight)
@@ -228,6 +254,24 @@ func (hl *HeimdallListener) ProcessBlockEvent(event sdk.StringEvent, blockHeight
 	}
 }
 
+func (hl *HeimdallListener) getCheckpointSyncKey(event sdk.StringEvent) string {
+	var rootChain string
+	var number, startBlock, endBlock uint64
+	for _, attr := range event.Attributes {
+		switch attr.Key {
+		case checkpointTypes.AttributeKeyRootChain:
+			rootChain = attr.Value
+		case checkpointTypes.AttributeKeyHeaderIndex:
+			number, _ = strconv.ParseUint(attr.Value, 10, 64)
+		case checkpointTypes.AttributeKeyStartBlock:
+			startBlock, _ = strconv.ParseUint(attr.Value, 10, 64)
+		case checkpointTypes.AttributeKeyEndBlock:
+			endBlock, _ = strconv.ParseUint(attr.Value, 10, 64)
+		}
+	}
+	return fmt.Sprintf("%s_%d_%d_%d", rootChain, number, startBlock, endBlock)
+}
+
 func (hl *HeimdallListener) sendBlockTask(taskName string, eventBytes []byte, blockHeight int64) {
 	// create machinery task
 	signature := &tasks.Signature{
@@ -293,12 +337,12 @@ func (hl *HeimdallListener) StartPollingEventRecord(ctx context.Context, pollInt
 }
 
 func (hl *HeimdallListener) loadEventRecords(ctx context.Context, pollInterval time.Duration) {
-	targetFeature, err := util.GetTargetFeatureConfig(hl.cliCtx, featureManagerTypes.DynamicCheckpoint)
-	if err != nil || !targetFeature.IsOpen {
-		hl.Logger.Info("Feature not supported... goroutine exists")
-
-		return
-	}
+	//targetFeature, err := util.GetTargetFeatureConfig(hl.cliCtx, featureManagerTypes.DynamicCheckpoint)
+	//if err != nil || !targetFeature.IsOpen {
+	//	hl.Logger.Info("Feature not supported... goroutine exists")
+	//
+	//	return
+	//}
 
 	if atomic.LoadUint32(&hl.stateSyncedInitializationRun) == 1 {
 		hl.Logger.Info("Last ProcessEventRecords not finished... goroutine exists")

bridge/setu/listener/maticchain.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/RichardKnop/machinery/v1/tasks"
+	"github.com/maticnetwork/heimdall/bridge/setu/util"
 	"github.com/maticnetwork/heimdall/helper"
 )
 
@@ -33,9 +34,15 @@ func (ml *MaticChainListener) Start() error {
 	// start header process
 	go ml.StartHeaderProcess(headerCtx)
 
-	ml.Logger.Info("Start polling for header blocks", "pollInterval", helper.GetConfig().CheckpointerPollInterval)
+	pollInterval := helper.GetConfig().CheckpointerPollInterval
+	params := util.GetCheckpointParamsWithRetry(ml.cliCtx)
+	if params.CheckpointPollInterval > 0 {
+		pollInterval = params.CheckpointPollInterval
+	}
+
+	ml.Logger.Info("Start polling for header blocks", "pollInterval", pollInterval)
 
-	go ml.StartPolling(ctx, helper.GetConfig().CheckpointerPollInterval, true, nil)
+	go ml.StartPolling(ctx, pollInterval, true, nil)
 
 	// subscribed to new head
 	ml.Logger.Info("Subscribed to new head")

bridge/setu/processor/checkpoint.go

@@ -99,15 +99,23 @@ func (cp *CheckpointProcessor) startPolling(ctx context.Context) {
 	now := time.Now()
 	baseTime := time.Unix(0, 0)
 	// no-ack ticker interval keep same with checkpoint interval
-	noAckInterval := helper.GetConfig().CheckpointerPollInterval
+	checkpointPollInterval := helper.GetConfig().CheckpointerPollInterval
+
+	// fetch initial checkpoint params (will retry up to 10 times or exit service)
+	checkpointParams := util.GetCheckpointParamsWithRetry(cp.cliCtx)
+	if checkpointParams.CheckpointPollInterval > 0 {
+		checkpointPollInterval = checkpointParams.CheckpointPollInterval
+	}
+
 	// adjust no-ack ticker to tick at the middle of checkpoint interval
-	firstIntervalForNoAck := noAckInterval - (now.UTC().Sub(baseTime) % noAckInterval) - noAckInterval/2 // nolint: gomnd
+	firstIntervalForNoAck := checkpointPollInterval - (now.UTC().Sub(baseTime) % checkpointPollInterval) - checkpointPollInterval/2 // nolint: gomnd
 	if firstIntervalForNoAck <= 0 {
-		firstIntervalForNoAck += noAckInterval
+		firstIntervalForNoAck += checkpointPollInterval
 	}
 
 	tickerForNoAck := time.NewTicker(firstIntervalForNoAck)
-	syncInterval := helper.GetConfig().CheckpointerPollInterval / 2
+	syncInterval := checkpointPollInterval / 2
+	noAckInterval := checkpointPollInterval
 	tickerForSync := time.NewTicker(syncInterval)
 	// stop ticker when everything done
 	defer tickerForNoAck.Stop()
@@ -568,10 +576,10 @@ func (cp *CheckpointProcessor) createAndSendCheckpointToHeimdall(checkpointConte
 	latestCheckpoint, err := util.GetlastestCheckpoint(cp.cliCtx, rootChain)
 	// event checkpoint is older than or equal to latest checkpoint
 	if err == nil && latestCheckpoint != nil && latestCheckpoint.EndBlock+1 < start {
-		cp.Logger.Debug("Need to resubmit Checkpoint ack first", "start", start, "last_end", latestCheckpoint.EndBlock)
+		cp.Logger.Info("Need to resubmit Checkpoint ack first", "start", start, "last_end", latestCheckpoint.EndBlock)
 		err := cp.resubmitCheckpointAck(checkpointContext, rootChain)
 		if err != nil {
-			cp.Logger.Info("Error while resubmit checkpoint ack", "root", rootChain, "err", err)
+			cp.Logger.Error("Error while resubmit checkpoint ack", "root", rootChain, "err", err)
 			return err
 		}
 		return nil
@@ -840,16 +848,40 @@ func (cp *CheckpointProcessor) checkIfNoAckIsRequired(checkpointContext *Checkpo
 	currentTime := time.Now().UTC()
 
 	timeDiff := currentTime.Sub(checkpointCreationTime)
-	if timeDiff.Seconds() >= helper.GetConfig().CheckpointerPollInterval.Seconds() && index == 0 {
-		index = math.Floor(timeDiff.Seconds() / helper.GetConfig().CheckpointerPollInterval.Seconds())
+
+	// checkpoint params
+	checkpointParams := checkpointContext.CheckpointParams
+
+	var checkpointPollInterval time.Duration
+	if checkpointParams.CheckpointPollInterval > 0 {
+		checkpointPollInterval = checkpointParams.CheckpointPollInterval
+	} else {
+		checkpointPollInterval = helper.GetConfig().CheckpointerPollInterval
 	}
 
-	if index == 0 {
+	var checkpointTimeout time.Duration
+	isOpen, tronMaxLength, err := cp.getTronDynamicCheckpointProposalWithErr()
+	if err != nil {
+		cp.Logger.Error("failed to check if no ack is required. Error while fetching dynamic checkpoint feature", "error", err)
 		return false, uint64(index)
 	}
+	if isOpen {
+		checkpointTimeout, err = helper.CalcCheckpointTimeout(tronMaxLength, checkpointPollInterval)
+		if err != nil {
+			cp.Logger.Error("failed to CalcCheckpointTimeout", "error", err)
+			return false, uint64(index)
+		}
+	} else {
+		checkpointTimeout = checkpointPollInterval
+	}
 
-	// checkpoint params
-	checkpointParams := checkpointContext.CheckpointParams
+	if timeDiff.Seconds() >= checkpointTimeout.Seconds() && index == 0 {
+		index = math.Floor(timeDiff.Seconds() / checkpointTimeout.Seconds())
+	}
+
+	if index == 0 {
+		return false, uint64(index)
+	}
 
 	// check if difference between no-ack time and current time
 	lastNoAck := cp.getLastNoAckTime()
@@ -991,9 +1023,7 @@ func (cp *CheckpointProcessor) Stop() {
 	cp.cancelNoACKPolling()
 }
 
-//
 // utils
-//
 func (cp *CheckpointProcessor) getCheckpointContext(rootChain string) (*CheckpointContext, error) {
 	// fetch chain params for different root chains
 	chainmanagerParams, err := util.GetNewChainParams(cp.cliCtx, rootChain)
@@ -1090,3 +1120,13 @@ func (cp *CheckpointProcessor) getDynamicCheckpointProposal(rootType string) (bo
 
 	return fea.IsOpen, fea.IntConf[strings.ToLower(rootType)] != 0, fea.IntConf["maxLength"]
 }
+
+func (cp *CheckpointProcessor) getTronDynamicCheckpointProposalWithErr() (bool, int, error) {
+	fea, err := util.GetTronDynamicCheckpointFeature(cp.cliCtx)
+	if err != nil {
+		cp.Logger.Error("Error while fetching dynamic checkpoint feature", "error", err)
+
+		return false, 0, err
+	}
+	return fea.IsOpen, fea.IntConf["maxLength"], err
+}

bridge/setu/processor/checkpointsync.go

@@ -147,7 +147,7 @@ func (cp *CheckpointProcessor) sendCheckpointSyncToStakeChain(eventBytes string,
 	} else {
 		txHash := common.FromHex(txHash)
 		if err := cp.createAndSendCheckpointSyncToTron(checkpointContext, number, startBlock, endBlock, rootChain, blockHeight, txHash); err != nil {
-			cp.Logger.Error("Error sending checkpoint to rootchain", "error", err)
+			cp.Logger.Error("Error sending checkpoint sync to rootchain", "error", err)
 			return err
 		}
 	}