Guardian now produces rollup based on interval time and available bat…

go/config/host_config.go

@@ -92,6 +92,9 @@ type HostInputConfig struct {
 
 	// Whether inbound p2p is enabled or not
 	IsInboundP2PDisabled bool
+
+	// MaxRollupSize specifies the threshold size which the sequencer-host publishes a rollup
+	MaxRollupSize uint64
 }
 
 // ToHostConfig returns a HostConfig given a HostInputConfig
@@ -131,6 +134,7 @@ func (p HostInputConfig) ToHostConfig() *HostConfig {
 		RollupInterval:            p.RollupInterval,
 		L1BlockTime:               p.L1BlockTime,
 		IsInboundP2PDisabled:      p.IsInboundP2PDisabled,
+		MaxRollupSize:             p.MaxRollupSize,
 	}
 }
 
@@ -156,6 +160,8 @@ type HostConfig struct {
 	BatchInterval time.Duration
 	// Min interval before creating the next rollup (only used by Sequencer nodes)
 	RollupInterval time.Duration
+	// MaxRollupSize is the max size of the rollup
+	MaxRollupSize uint64
 	// The expected time between blocks on the L1 network
 	L1BlockTime time.Duration
 
@@ -255,5 +261,6 @@ func DefaultHostParsedConfig() *HostInputConfig {
 		RollupInterval:            5 * time.Second,
 		L1BlockTime:               15 * time.Second,
 		IsInboundP2PDisabled:      false,
+		MaxRollupSize:             1024 * 64,
 	}
 }

go/enclave/components/batch_registry.go

@@ -6,7 +6,6 @@ import (
 	"sync"
 
 	"github.com/ethereum/go-ethereum/core/types"
-
 	"github.com/obscuronet/go-obscuro/go/enclave/storage"
 
 	"github.com/ethereum/go-ethereum/core/state"

go/host/container/cli.go

@@ -89,6 +89,7 @@ func ParseConfig() (*config.HostInputConfig, error) {
 	batchInterval := flag.String(batchIntervalName, cfg.BatchInterval.String(), flagUsageMap[batchIntervalName])
 	rollupInterval := flag.String(rollupIntervalName, cfg.RollupInterval.String(), flagUsageMap[rollupIntervalName])
 	isInboundP2PDisabled := flag.Bool(isInboundP2PDisabledName, cfg.IsInboundP2PDisabled, flagUsageMap[isInboundP2PDisabledName])
+	maxRollupSize := flag.Uint64(maxRollupSizeFlagName, cfg.MaxRollupSize, flagUsageMap[maxRollupSizeFlagName])
 
 	flag.Parse()
 
@@ -139,6 +140,7 @@ func ParseConfig() (*config.HostInputConfig, error) {
 		return nil, err
 	}
 	cfg.IsInboundP2PDisabled = *isInboundP2PDisabled
+	cfg.MaxRollupSize = *maxRollupSize
 
 	return cfg, nil
 }

go/host/container/cli_flags.go

@@ -34,6 +34,7 @@ const (
 	batchIntervalName            = "batchInterval"
 	rollupIntervalName           = "rollupInterval"
 	isInboundP2PDisabledName     = "isInboundP2PDisabled"
+	maxRollupSizeFlagName        = "maxRollupSize"
 )
 
 // Returns a map of the flag usages.
@@ -72,5 +73,6 @@ func getFlagUsageMap() map[string]string {
 		batchIntervalName:            "Duration between each batch. Can be put down as 1.0s",
 		rollupIntervalName:           "Duration between each rollup. Can be put down as 1.0s",
 		isInboundP2PDisabledName:     "Whether inbound p2p is enabled",
+		maxRollupSizeFlagName:        "Max size of a rollup",
 	}
 }

go/host/enclave/guardian.go

@@ -63,6 +63,7 @@ type Guardian struct {
 	batchInterval  time.Duration
 	rollupInterval time.Duration
 	l1StartHash    gethcommon.Hash
+	maxRollupSize  uint64
 
 	hostInterrupter *stopcontrol.StopControl // host hostInterrupter so we can stop quickly
 
@@ -78,6 +79,7 @@ func NewGuardian(cfg *config.HostConfig, hostData host.Identity, serviceLocator
 		batchInterval:   cfg.BatchInterval,
 		rollupInterval:  cfg.RollupInterval,
 		l1StartHash:     cfg.L1StartHash,
+		maxRollupSize:   cfg.MaxRollupSize,
 		db:              db,
 		hostInterrupter: interrupter,
 		logger:          logger,
@@ -515,45 +517,81 @@ func (g *Guardian) periodicBatchProduction() {
 	}
 }
 
-func (g *Guardian) periodicRollupProduction() {
+func (g *Guardian) periodicRollupProduction() { //nolint:gocognit
 	defer g.logger.Info("Stopping rollup production")
 
-	interval := g.rollupInterval
-	if interval == 0 {
-		interval = 3 * time.Second
+	// rollup at least at every g.rollupInterval
+	rollupInterval := g.rollupInterval
+	if rollupInterval == 0 {
+		g.logger.Crit("invalid rollup interval 0")
 	}
-	rollupTicker := time.NewTicker(interval)
-	// attempt to produce rollup every time the timer ticks until we are stopped/interrupted
+	rollupIntervalBasedTicker := time.NewTicker(rollupInterval)
+
+	// every 5sec check if it should create a new rollup
+	rollupSizeCheckTicker := time.NewTicker(5 * time.Second)
+
 	for {
-		if g.hostInterrupter.IsStopping() {
-			rollupTicker.Stop()
-			return // stop periodic rollup production
-		}
 		select {
-		case <-rollupTicker.C:
+		case <-rollupIntervalBasedTicker.C:
 			if !g.state.IsUpToDate() {
 				// if we're behind the L1, we don't want to produce rollups
 				g.logger.Debug("skipping rollup production because L1 is not up to date", "state", g.state)
 				continue
 			}
-			lastBatchNo, err := g.sl.L1Publisher().FetchLatestSeqNo()
+
+			fromBatch, err := g.getLastestBatchNo()
 			if err != nil {
 				g.logger.Warn("encountered error while trying to retrieve latest sequence number", log.ErrKey, err)
 				continue
 			}
-			fromBatch := lastBatchNo.Uint64()
-			if lastBatchNo.Uint64() > common.L2GenesisSeqNo {
-				fromBatch++
-			}
+
 			producedRollup, err := g.enclaveClient.CreateRollup(fromBatch)
 			if err != nil {
 				g.logger.Error("unable to produce rollup", log.ErrKey, err)
 			} else {
+				fmt.Println(time.Now().String(), " - PRODUCING rollup from config'd rollupInterval - lastBatchNo: ", fromBatch)
 				g.sl.L1Publisher().PublishRollup(producedRollup)
+				fmt.Println(time.Now().String(), " - FINISHED PRODUCED rollup from config'd rollupInterval ")
+			}
+
+		case <-rollupSizeCheckTicker.C:
+			if !g.state.IsUpToDate() {
+				// if we're behind the L1, we don't want to produce rollups
+				g.logger.Debug("skipping rollup production because L1 is not up to date", "state", g.state)
+				continue
+			}
+
+			fromBatch, err := g.getLastestBatchNo()
+			if err != nil {
+				g.logger.Warn("encountered error while trying to retrieve latest sequence number", log.ErrKey, err)
+				continue
 			}
+
+			fmt.Println(time.Now().String(), " - 5sec rollup creation CHECK - lastBatchNo: ", fromBatch)
+			availBatchesSumSize, err := g.getBatchesAfterSize(fromBatch)
+			if err != nil {
+				g.logger.Error("unable to GetBatchesAfterSize rollup", log.ErrKey, err)
+				continue
+			}
+
+			fmt.Println(time.Now().String(), " - Sum of bytes of Batches not yet rolled up: - ", availBatchesSumSize, " bytes")
+			if availBatchesSumSize >= g.maxRollupSize {
+				producedRollup, err := g.enclaveClient.CreateRollup(fromBatch)
+				if err != nil {
+					g.logger.Error("unable to produce rollup", log.ErrKey, err)
+				} else {
+					fmt.Println(time.Now().String(), " - PRODUCING rollup from 5sec check ")
+					g.sl.L1Publisher().PublishRollup(producedRollup)
+				}
+				rollupSizeCheckTicker.Reset(5 * time.Second)
+				rollupIntervalBasedTicker.Reset(rollupInterval)
+				fmt.Println(time.Now().String(), " - FINISHED PRODUCING rollup from 5sec check ")
+			}
+
 		case <-g.hostInterrupter.Done():
 			// interrupted - end periodic process
-			rollupTicker.Stop()
+			rollupIntervalBasedTicker.Stop()
+			rollupSizeCheckTicker.Stop()
 			return
 		}
 	}
@@ -608,3 +646,40 @@ func (g *Guardian) streamEnclaveData() {
 		}
 	}
 }
+
+func (g *Guardian) getBatchesAfterSize(seqNo uint64) (uint64, error) {
+	var size uint64
+
+	currentNo := seqNo
+	for {
+		batch, err := g.sl.L2Repo().FetchBatchBySeqNo(big.NewInt(int64(currentNo)))
+		if err != nil {
+			if errors.Is(err, errutil.ErrNotFound) {
+				break // no more batches
+			}
+			return 0, err
+		}
+
+		bSize, err := batch.Size()
+		if err != nil {
+			return 0, err
+		}
+		size += uint64(bSize)
+		currentNo++
+	}
+
+	return size, nil
+}
+
+func (g *Guardian) getLastestBatchNo() (uint64, error) {
+	lastBatchNo, err := g.sl.L1Publisher().FetchLatestSeqNo()
+	if err != nil {
+		fmt.Println(err)
+		return 0, err
+	}
+	fromBatch := lastBatchNo.Uint64()
+	if lastBatchNo.Uint64() > common.L2GenesisSeqNo {
+		fromBatch++
+	}
+	return fromBatch, nil
+}

integration/simulation/devnetwork/node.go

@@ -132,6 +132,7 @@ func (n *InMemNodeOperator) createHostContainer() *hostcontainer.HostContainer {
 		BatchInterval:             n.config.BatchInterval,
 		RollupInterval:            n.config.RollupInterval,
 		L1BlockTime:               n.config.L1BlockTime,
+		MaxRollupSize:             1024 * 64,
 	}
 
 	hostLogger := testlog.Logger().New(log.NodeIDKey, n.l1Wallet.Address(), log.CmpKey, log.HostCmp)