1. Improve performance of rollup creation by saving the list of block…

…s after they are fetched the first time.

2. Set maximum memory for cache.
3. Reduce cache memory consumption by caching a mapping between a batch hash and a batch sequence

go/enclave/components/batch_registry.go

@@ -91,44 +91,46 @@ func (br *batchRegistry) HasGenesisBatch() (bool, error) {
 	return genesisBatchStored, nil
 }
 
-func (br *batchRegistry) BatchesAfter(batchSeqNo uint64, upToL1Height uint64, rollupLimiter limiters.RollupLimiter) ([]*core.Batch, error) {
+func (br *batchRegistry) BatchesAfter(batchSeqNo uint64, upToL1Height uint64, rollupLimiter limiters.RollupLimiter) ([]*core.Batch, []*types.Block, error) {
 	// sanity check
 	headBatch, err := br.storage.FetchHeadBatch()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	if headBatch.SeqNo().Uint64() < batchSeqNo {
-		return nil, fmt.Errorf("head batch height %d is in the past compared to requested batch %d", headBatch.SeqNo().Uint64(), batchSeqNo)
+		return nil, nil, fmt.Errorf("head batch height %d is in the past compared to requested batch %d", headBatch.SeqNo().Uint64(), batchSeqNo)
 	}
 
 	resultBatches := make([]*core.Batch, 0)
+	resultBlocks := make([]*types.Block, 0)
 
 	currentBatchSeq := batchSeqNo
 	var currentBlock *types.Block
 	for currentBatchSeq <= headBatch.SeqNo().Uint64() {
 		batch, err := br.storage.FetchBatchBySeqNo(currentBatchSeq)
 		if err != nil {
-			return nil, fmt.Errorf("could not retrieve batch by sequence number %d. Cause: %w", currentBatchSeq, err)
+			return nil, nil, fmt.Errorf("could not retrieve batch by sequence number %d. Cause: %w", currentBatchSeq, err)
 		}
 
 		// check the block height
 		// if it's the same block as the previous batch there is no reason to check
 		if currentBlock == nil || currentBlock.Hash() != batch.Header.L1Proof {
 			block, err := br.storage.FetchBlock(batch.Header.L1Proof)
 			if err != nil {
-				return nil, fmt.Errorf("could not retrieve block. Cause: %w", err)
+				return nil, nil, fmt.Errorf("could not retrieve block. Cause: %w", err)
 			}
 			currentBlock = block
 			if block.NumberU64() > upToL1Height {
 				break
 			}
+			resultBlocks = append(resultBlocks, block)
 		}
 
 		// check the limiter
 		didAcceptBatch, err := rollupLimiter.AcceptBatch(batch)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		if !didAcceptBatch {
 			break
@@ -145,12 +147,12 @@ func (br *batchRegistry) BatchesAfter(batchSeqNo uint64, upToL1Height uint64, ro
 		current := resultBatches[0].SeqNo().Uint64()
 		for i, b := range resultBatches {
 			if current+uint64(i) != b.SeqNo().Uint64() {
-				return nil, fmt.Errorf("created invalid rollup with batches out of sequence")
+				return nil, nil, fmt.Errorf("created invalid rollup with batches out of sequence")
 			}
 		}
 	}
 
-	return resultBatches, nil
+	return resultBatches, resultBlocks, nil
 }
 
 func (br *batchRegistry) GetBatchStateAtHeight(blockNumber *gethrpc.BlockNumber) (*state.StateDB, error) {

go/enclave/components/interfaces.go

@@ -80,7 +80,7 @@ type BatchExecutor interface {
 
 type BatchRegistry interface {
 	// BatchesAfter - Given a hash, will return batches following it until the head batch
-	BatchesAfter(batchSeqNo uint64, upToL1Height uint64, rollupLimiter limiters.RollupLimiter) ([]*core.Batch, error)
+	BatchesAfter(batchSeqNo uint64, upToL1Height uint64, rollupLimiter limiters.RollupLimiter) ([]*core.Batch, []*types.Block, error)
 
 	// GetBatchStateAtHeight - creates a stateDB that represents the state committed when
 	// the batch with height matching the blockNumber was created and stored.
@@ -104,9 +104,8 @@ type BatchRegistry interface {
 }
 
 type RollupProducer interface {
-	// CreateRollup - creates a rollup starting from the end of the last rollup
-	// that has been stored and continues it towards what we consider the current L2 head.
-	CreateRollup(fromBatchNo uint64, upToL1Height uint64, limiter limiters.RollupLimiter) (*core.Rollup, error)
+	// CreateInternalRollup - creates a rollup starting from the end of the last rollup that has been stored on the L1
+	CreateInternalRollup(fromBatchNo uint64, upToL1Height uint64, limiter limiters.RollupLimiter) (*core.Rollup, error)
 }
 
 type RollupConsumer interface {

go/enclave/components/rollup_compression.go

@@ -91,7 +91,7 @@ type batchFromRollup struct {
 
 // CreateExtRollup - creates a compressed and encrypted External rollup from the internal data structure
 func (rc *RollupCompression) CreateExtRollup(r *core.Rollup) (*common.ExtRollup, error) {
-	header, err := rc.createRollupHeader(r.Batches)
+	header, err := rc.createRollupHeader(r)
 	if err != nil {
 		return nil, err
 	}
@@ -148,7 +148,8 @@ func (rc *RollupCompression) ProcessExtRollup(rollup *common.ExtRollup) (*common
 }
 
 // the main logic that goes from a list of batches to the rollup header
-func (rc *RollupCompression) createRollupHeader(batches []*core.Batch) (*common.CalldataRollupHeader, error) {
+func (rc *RollupCompression) createRollupHeader(rollup *core.Rollup) (*common.CalldataRollupHeader, error) {
+	batches := rollup.Batches
 	reorgs := make([]*common.BatchHeader, len(batches))
 
 	deltaTimes := make([]*big.Int, len(batches))
@@ -172,7 +173,7 @@ func (rc *RollupCompression) createRollupHeader(batches []*core.Batch) (*common.
 	}
 
 	for i, batch := range batches {
-		rc.logger.Debug("Compressing batch to rollup", log.BatchSeqNoKey, batch.SeqNo(), log.BatchHeightKey, batch.Number(), log.BatchHashKey, batch.Hash())
+		rc.logger.Info("Compressing batch to rollup", log.BatchSeqNoKey, batch.SeqNo(), log.BatchHeightKey, batch.Number(), log.BatchHashKey, batch.Hash())
 		// determine whether the batch is canonical
 		if reorgMap[batch.SeqNo().Uint64()] {
 			// if the canonical batch of the same height is different from the current batch
@@ -189,10 +190,7 @@ func (rc *RollupCompression) createRollupHeader(batches []*core.Batch) (*common.
 		prev = batch.Header.Time
 
 		// since this is the sequencer, it must have all the blocks, because it created the batches in the first place
-		block, err := rc.storage.FetchBlock(batch.Header.L1Proof)
-		if err != nil {
-			return nil, err
-		}
+		block := rollup.Blocks[batch.Header.L1Proof]
 
 		// the first element is the actual height
 		if i == 0 {

go/enclave/components/rollup_producer.go

@@ -13,47 +13,30 @@ import (
 	"github.com/obscuronet/go-obscuro/contracts/generated/MessageBus"
 
 	"github.com/obscuronet/go-obscuro/go/common"
-	"github.com/obscuronet/go-obscuro/go/enclave/crypto"
 	"github.com/obscuronet/go-obscuro/go/enclave/limiters"
 
 	gethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/obscuronet/go-obscuro/go/enclave/core"
 )
 
-// rollupProducerImpl encapsulates the logic of decoding rollup transactions submitted to the L1 and resolving them
-// to rollups that the enclave can process.
 type rollupProducerImpl struct {
-	// TransactionBlobCrypto- This contains the required properties to encrypt rollups.
-	TransactionBlobCrypto crypto.DataEncryptionService
-
-	ObscuroChainID  int64
-	EthereumChainID int64
-
-	sequencerID gethcommon.Address
-
-	logger gethlog.Logger
-
-	storage storage.Storage
-
-	batchRegistry  BatchRegistry
-	blockProcessor L1BlockProcessor
+	sequencerID   gethcommon.Address
+	storage       storage.Storage
+	batchRegistry BatchRegistry
+	logger        gethlog.Logger
 }
 
-func NewRollupProducer(sequencerID gethcommon.Address, transactionBlobCrypto crypto.DataEncryptionService, obscuroChainID int64, ethereumChainID int64, storage storage.Storage, batchRegistry BatchRegistry, blockProcessor L1BlockProcessor, logger gethlog.Logger) RollupProducer {
+func NewRollupProducer(sequencerID gethcommon.Address, storage storage.Storage, batchRegistry BatchRegistry, logger gethlog.Logger) RollupProducer {
 	return &rollupProducerImpl{
-		TransactionBlobCrypto: transactionBlobCrypto,
-		ObscuroChainID:        obscuroChainID,
-		EthereumChainID:       ethereumChainID,
-		sequencerID:           sequencerID,
-		logger:                logger,
-		batchRegistry:         batchRegistry,
-		blockProcessor:        blockProcessor,
-		storage:               storage,
+		sequencerID:   sequencerID,
+		logger:        logger,
+		batchRegistry: batchRegistry,
+		storage:       storage,
 	}
 }
 
-func (re *rollupProducerImpl) CreateRollup(fromBatchNo uint64, upToL1Height uint64, limiter limiters.RollupLimiter) (*core.Rollup, error) {
-	batches, err := re.batchRegistry.BatchesAfter(fromBatchNo, upToL1Height, limiter)
+func (re *rollupProducerImpl) CreateInternalRollup(fromBatchNo uint64, upToL1Height uint64, limiter limiters.RollupLimiter) (*core.Rollup, error) {
+	batches, blocks, err := re.batchRegistry.BatchesAfter(fromBatchNo, upToL1Height, limiter)
 	if err != nil {
 		return nil, fmt.Errorf("could not fetch 'from' batch (seqNo=%d) for rollup: %w", fromBatchNo, err)
 	}
@@ -68,17 +51,6 @@ func (re *rollupProducerImpl) CreateRollup(fromBatchNo uint64, upToL1Height uint
 	if err != nil {
 		return nil, err
 	}
-	newRollup := re.createNextRollup(batches, block)
-
-	re.logger.Info(fmt.Sprintf("Created new rollup %s with %d batches. From %d to %d", newRollup.Hash(), len(newRollup.Batches), batches[0].SeqNo(), batches[len(batches)-1].SeqNo()))
-
-	return newRollup, nil
-}
-
-// createNextRollup - based on a previous rollup and batches will create a new rollup that encapsulate the state
-// transition from the old rollup to the new one's head batch.
-func (re *rollupProducerImpl) createNextRollup(batches []*core.Batch, block *types.Block) *core.Rollup {
-	lastBatch := batches[len(batches)-1]
 
 	rh := common.RollupHeader{}
 	rh.CompressionL1Head = block.Hash()
@@ -89,9 +61,21 @@ func (re *rollupProducerImpl) createNextRollup(batches []*core.Batch, block *typ
 		rh.CrossChainMessages = append(rh.CrossChainMessages, b.Header.CrossChainMessages...)
 	}
 
+	lastBatch := batches[len(batches)-1]
 	rh.LastBatchSeqNo = lastBatch.SeqNo().Uint64()
-	return &core.Rollup{
+
+	blockMap := map[common.L1BlockHash]*types.Block{}
+	for _, b := range blocks {
+		blockMap[b.Hash()] = b
+	}
+
+	newRollup := &core.Rollup{
 		Header:  &rh,
+		Blocks:  blockMap,
 		Batches: batches,
 	}
+
+	re.logger.Info(fmt.Sprintf("Created new rollup %s with %d batches. From %d to %d", newRollup.Hash(), len(newRollup.Batches), batches[0].SeqNo(), rh.LastBatchSeqNo))
+
+	return newRollup, nil
 }

go/enclave/core/rollup.go

@@ -4,13 +4,16 @@ import "C"
 import (
 	"sync/atomic"
 
+	"github.com/ethereum/go-ethereum/core/types"
+
 	"github.com/obscuronet/go-obscuro/go/common"
 )
 
-// todo - This should be a synthetic datastructure
+// Rollup - is an internal data structure useful during creation
 type Rollup struct {
 	Header  *common.RollupHeader
 	Batches []*Batch
+	Blocks  map[common.L1BlockHash]*types.Block // these are the blocks required during compression. The key is the hash
 	hash    atomic.Value
 }
 

go/enclave/enclave.go

@@ -211,7 +211,7 @@ func NewEnclave(
 	batchExecutor := components.NewBatchExecutor(storage, crossChainProcessors, genesis, gasOracle, &chainConfig, logger)
 	sigVerifier, err := components.NewSignatureValidator(config.SequencerID, storage)
 	registry := components.NewBatchRegistry(storage, logger)
-	rProducer := components.NewRollupProducer(config.SequencerID, dataEncryptionService, config.ObscuroChainID, config.L1ChainID, storage, registry, blockProcessor, logger)
+	rProducer := components.NewRollupProducer(config.SequencerID, storage, registry, logger)
 	if err != nil {
 		logger.Crit("Could not initialise the signature validator", log.ErrKey, err)
 	}

go/enclave/nodetype/sequencer.go

@@ -259,17 +259,22 @@ func (s *sequencer) CreateRollup(lastBatchNo uint64) (*common.ExtRollup, error)
 		return nil, err
 	}
 	upToL1Height := currentL1Head.NumberU64() - RollupDelay
-	rollup, err := s.rollupProducer.CreateRollup(lastBatchNo, upToL1Height, rollupLimiter)
+	rollup, err := s.rollupProducer.CreateInternalRollup(lastBatchNo, upToL1Height, rollupLimiter)
 	if err != nil {
 		return nil, err
 	}
 
+	extRollup, err := s.rollupCompression.CreateExtRollup(rollup)
+	if err != nil {
+		return nil, fmt.Errorf("failed to compress rollup: %w", err)
+	}
+
 	// todo - double-check that this signing approach is secure, and it properly includes the entire payload
-	if err := s.signRollup(rollup); err != nil {
+	if err := s.signRollup(extRollup); err != nil {
 		return nil, fmt.Errorf("failed to sign created rollup: %w", err)
 	}
 
-	return s.rollupCompression.CreateExtRollup(rollup)
+	return extRollup, nil
 }
 
 func (s *sequencer) duplicateBatches(l1Head *types.Block, nonCanonicalL1Path []common.L1BlockHash) error {
@@ -358,7 +363,7 @@ func (s *sequencer) signBatch(batch *core.Batch) error {
 	return nil
 }
 
-func (s *sequencer) signRollup(rollup *core.Rollup) error {
+func (s *sequencer) signRollup(rollup *common.ExtRollup) error {
 	var err error
 	h := rollup.Header.Hash()
 	rollup.Header.R, rollup.Header.S, err = ecdsa.Sign(rand.Reader, s.enclavePrivateKey, h[:])

go/enclave/storage/storage.go

@@ -40,23 +40,23 @@ import (
 	gethlog "github.com/ethereum/go-ethereum/log"
 )
 
-// todo - this will require a dedicated table when updates are implemented
+// todo - this will require a dedicated table when upgrades are implemented
 const (
-	masterSeedCfg                 = "MASTER_SEED"
-	_slowCallDebugThresholdMillis = 50  // requests that take longer than this will be logged with DEBUG
-	_slowCallInfoThresholdMillis  = 100 // requests that take longer than this will be logged with INFO
-	_slowCallWarnThresholdMillis  = 200 // requests that take longer than this will be logged with WARN
-	_slowCallErrorThresholdMillis = 500 // requests that take longer than this will be logged with ERROR
+	masterSeedCfg = "MASTER_SEED"
 )
 
 type storageImpl struct {
 	db enclavedb.EnclaveDB
 
-	// cache for the immutable batches and blocks.
+	// cache for the immutable blocks and batches.
 	// this avoids a trip to the database.
-	batchCache *cache.Cache[[]byte]
 	blockCache *cache.Cache[[]byte]
 
+	// stores batches using the sequence number as key
+	// stores a mapping between the hash and the sequence number
+	// to fetch a batch by hash will require 2 cache hits
+	batchCache *cache.Cache[[]byte]
+
 	stateDB     state.Database
 	chainConfig *params.ChainConfig
 	logger      gethlog.Logger
@@ -80,7 +80,9 @@ func NewStorage(backingDB enclavedb.EnclaveDB, chainConfig *params.ChainConfig,
 	}
 
 	// todo (tudor) figure out the context and the config
-	bigcacheClient, err := bigcache.New(context.Background(), bigcache.DefaultConfig(5*time.Minute))
+	cfg := bigcache.DefaultConfig(2 * time.Minute)
+	cfg.HardMaxCacheSize = 512
+	bigcacheClient, err := bigcache.New(context.Background(), cfg)
 	if err != nil {
 		logger.Crit("Could not initialise bigcache", log.ErrKey, err)
 	}
@@ -120,9 +122,18 @@ func (s *storageImpl) FetchCurrentSequencerNo() (*big.Int, error) {
 
 func (s *storageImpl) FetchBatch(hash common.L2BatchHash) (*core.Batch, error) {
 	defer s.logDuration("FetchBatch", measure.NewStopwatch())
-	return getCachedValue(s.batchCache, s.logger, hash, func(v any) (*core.Batch, error) {
-		return enclavedb.ReadBatchByHash(s.db.GetSQLDB(), v.(common.L2BatchHash))
+	seqNo, err := getCachedValue(s.batchCache, s.logger, hash, func(v any) (*big.Int, error) {
+		batch, err := enclavedb.ReadBatchByHash(s.db.GetSQLDB(), v.(common.L2BatchHash))
+		if err != nil {
+			return nil, err
+		}
+		cacheValue(s.batchCache, s.logger, batch.SeqNo(), batch)
+		return batch.SeqNo(), nil
 	})
+	if err != nil {
+		return nil, err
+	}
+	return s.FetchBatchBySeqNo(seqNo.Uint64())
 }
 
 func (s *storageImpl) FetchBatchHeader(hash common.L2BatchHash) (*common.BatchHeader, error) {
@@ -181,10 +192,7 @@ func (s *storageImpl) FetchCanonicaBlockByHeight(height *big.Int) (*types.Block,
 	if err != nil {
 		return nil, err
 	}
-	blockHash := header.Hash()
-	return getCachedValue(s.blockCache, s.logger, blockHash, func(hash any) (*types.Block, error) {
-		return enclavedb.FetchBlock(s.db.GetSQLDB(), hash.(common.L2BatchHash))
-	})
+	return s.FetchBlock(header.Hash())
 }
 
 func (s *storageImpl) FetchHeadBlock() (*types.Block, error) {
@@ -366,7 +374,8 @@ func (s *storageImpl) StoreBatch(batch *core.Batch) error {
 		return fmt.Errorf("could not commit batch %w", err)
 	}
 
-	cacheValue(s.batchCache, s.logger, batch.Hash(), batch)
+	cacheValue(s.batchCache, s.logger, batch.SeqNo(), batch)
+	cacheValue(s.batchCache, s.logger, batch.Hash(), batch.SeqNo())
 	return nil
 }
 

go/host/enclave/guardian.go

@@ -552,7 +552,10 @@ func (g *Guardian) periodicRollupProduction() {
 			// produce and issue rollup when either:
 			// it has passed g.rollupInterval from last lastSuccessfulRollup
 			// or the size of accumulated batches is > g.maxRollupSize
-			if time.Since(lastSuccessfulRollup) > g.rollupInterval || availBatchesSumSize >= g.maxRollupSize {
+			timeExpired := time.Since(lastSuccessfulRollup) > g.rollupInterval
+			sizeExceeded := availBatchesSumSize >= g.maxRollupSize
+			if timeExpired || sizeExceeded {
+				g.logger.Info("Trigger rollup production.", "timeExpired", timeExpired, "sizeExceeded", sizeExceeded)
 				producedRollup, err := g.enclaveClient.CreateRollup(fromBatch)
 				if err != nil {
 					g.logger.Error("Unable to create rollup", log.BatchSeqNoKey, fromBatch, log.ErrKey, err)