Fix the msg bus deploy at genesis

go/enclave/components/batch_executor.go

@@ -208,7 +208,8 @@ func (executor *batchExecutor) ComputeBatch(context *BatchExecutionContext, fail
 		return nil, fmt.Errorf("failed adding cross chain data to batch. Cause: %w", err)
 	}
 
-	executor.populateHeader(&copyBatch, allReceipts(txReceipts, ccReceipts))
+	allReceipts := append(txReceipts, ccReceipts...)
+	executor.populateHeader(&copyBatch, allReceipts)
 	if failForEmptyBatch &&
 		len(txReceipts) == 0 &&
 		len(ccReceipts) == 0 &&
@@ -220,7 +221,7 @@ func (executor *batchExecutor) ComputeBatch(context *BatchExecutionContext, fail
 	}
 
 	// the logs and receipts produced by the EVM have the wrong hash which must be adjusted
-	for _, receipt := range txReceipts {
+	for _, receipt := range allReceipts {
 		receipt.BlockHash = copyBatch.Hash()
 		for _, l := range receipt.Logs {
 			l.BlockHash = copyBatch.Hash()
@@ -229,7 +230,7 @@ func (executor *batchExecutor) ComputeBatch(context *BatchExecutionContext, fail
 
 	return &ComputedBatch{
 		Batch:    &copyBatch,
-		Receipts: txReceipts,
+		Receipts: allReceipts,
 		Commit: func(deleteEmptyObjects bool) (gethcommon.Hash, error) {
 			executor.stateDBMutex.Lock()
 			defer executor.stateDBMutex.Unlock()
@@ -429,10 +430,6 @@ func (executor *batchExecutor) processTransactions(
 	return executedTransactions, excludedTransactions, txReceipts, nil
 }
 
-func allReceipts(txReceipts []*types.Receipt, depositReceipts []*types.Receipt) types.Receipts {
-	return append(txReceipts, depositReceipts...)
-}
-
 type sortByTxIndex []*types.Receipt
 
 func (c sortByTxIndex) Len() int           { return len(c) }

go/enclave/nodetype/sequencer.go

@@ -164,12 +164,33 @@ func (s *sequencer) createGenesisBatch(block *common.L1Block) error {
 		return err
 	}
 
-	// make sure the mempool queuing system is initialized before adding the msg bus tx to it
-	time.Sleep(time.Second)
+	// produce batch #2 which has the message bus and any other system contracts
+	cb, err := s.produceBatch(
+		batch.Header.SequencerOrderNo.Add(batch.Header.SequencerOrderNo, big.NewInt(1)),
+		block.Hash(),
+		batch.Hash(),
+		common.L2Transactions{msgBusTx},
+		uint64(time.Now().Unix()),
+		false,
+	)
+	if err != nil {
+		if errors.Is(err, components.ErrNoTransactionsToProcess) {
+			// skip batch production when there are no transactions to process
+			// todo: this might be a useful event to track for metrics (skipping batch production because empty batch)
+			s.logger.Debug("Skipping batch production, no transactions to execute")
+			return nil
+		}
+		return fmt.Errorf(" failed producing batch. Cause: %w", err)
+	}
 
-	if err = s.mempool.Add(msgBusTx); err != nil {
-		return fmt.Errorf("failed to queue message bus creation transaction to genesis - %w", err)
+	if len(cb.Receipts) == 0 || cb.Receipts[0].TxHash.Hex() != msgBusTx.Hash().Hex() {
+		err = fmt.Errorf("message Bus contract not minted - no receipts in batch")
+		s.logger.Error(err.Error())
+		return err
 	}
+
+	s.logger.Info("Message Bus Contract minted successfully", "address", cb.Receipts[0].ContractAddress.Hex())
+
 	return nil
 }
 
@@ -232,7 +253,14 @@ func (s *sequencer) createNewHeadBatch(l1HeadBlock *common.L1Block, skipBatchIfE
 	return nil
 }
 
-func (s *sequencer) produceBatch(sequencerNo *big.Int, l1Hash common.L1BlockHash, headBatch common.L2BatchHash, transactions common.L2Transactions, batchTime uint64, failForEmptyBatch bool) (*core.Batch, error) {
+func (s *sequencer) produceBatch(
+	sequencerNo *big.Int,
+	l1Hash common.L1BlockHash,
+	headBatch common.L2BatchHash,
+	transactions common.L2Transactions,
+	batchTime uint64,
+	failForEmptyBatch bool,
+) (*components.ComputedBatch, error) {
 	cb, err := s.batchProducer.ComputeBatch(&components.BatchExecutionContext{
 		BlockPtr:     l1Hash,
 		ParentPtr:    headBatch,
@@ -268,7 +296,7 @@ func (s *sequencer) produceBatch(sequencerNo *big.Int, l1Hash common.L1BlockHash
 		return nil, fmt.Errorf("unable to remove tx from mempool - %w", err)
 	}
 
-	return cb.Batch, nil
+	return cb, nil
 }
 
 // StoreExecutedBatch - stores an executed batch in one go. This can be done for the sequencer because it is guaranteed
@@ -359,11 +387,11 @@ func (s *sequencer) duplicateBatches(l1Head *types.Block, nonCanonicalL1Path []c
 		}
 		sequencerNo = sequencerNo.Add(sequencerNo, big.NewInt(1))
 		// create the duplicate and store/broadcast it, recreate batch even if it was empty
-		b, err := s.produceBatch(sequencerNo, l1Head.ParentHash(), currentHead, orphanBatch.Transactions, orphanBatch.Header.Time, false)
+		cb, err := s.produceBatch(sequencerNo, l1Head.ParentHash(), currentHead, orphanBatch.Transactions, orphanBatch.Header.Time, false)
 		if err != nil {
 			return fmt.Errorf("could not produce batch. Cause %w", err)
 		}
-		currentHead = b.Hash()
+		currentHead = cb.Batch.Hash()
 		s.logger.Info("Duplicated batch", log.BatchHashKey, currentHead)
 	}
 

integration/obscuroscan/obscuroscan_test.go

@@ -81,12 +81,12 @@ func TestObscuroscan(t *testing.T) {
 	statusCode, body, err := fasthttp.Get(nil, fmt.Sprintf("%s/count/contracts/", serverAddress))
 	assert.NoError(t, err)
 	assert.Equal(t, 200, statusCode)
-	assert.Equal(t, "{\"count\":1}", string(body))
+	assert.Equal(t, "{\"count\":2}", string(body))
 
 	statusCode, body, err = fasthttp.Get(nil, fmt.Sprintf("%s/count/transactions/", serverAddress))
 	assert.NoError(t, err)
 	assert.Equal(t, 200, statusCode)
-	assert.Equal(t, "{\"count\":5}", string(body))
+	assert.Equal(t, "{\"count\":6}", string(body))
 
 	statusCode, body, err = fasthttp.Get(nil, fmt.Sprintf("%s/items/batch/latest/", serverAddress))
 	assert.NoError(t, err)
@@ -120,8 +120,8 @@ func TestObscuroscan(t *testing.T) {
 	publicTxsObj := publicTxsRes{}
 	err = json.Unmarshal(body, &publicTxsObj)
 	assert.NoError(t, err)
-	assert.Equal(t, 5, len(publicTxsObj.Result.TransactionsData))
-	assert.Equal(t, uint64(5), publicTxsObj.Result.Total)
+	assert.Equal(t, 6, len(publicTxsObj.Result.TransactionsData))
+	assert.Equal(t, uint64(6), publicTxsObj.Result.Total)
 
 	statusCode, body, err = fasthttp.Get(nil, fmt.Sprintf("%s/items/batches/?offset=0&size=10", serverAddress))
 	assert.NoError(t, err)