Merge branch 'develop' into reset_skipped_traces

Author: mask-pp

core/rawdb/accessors_skipped_txs.go

@@ -58,7 +58,7 @@ type SkippedTransaction struct {
 	// BlockNumber is the number of the block in which this transaction was skipped.
 	BlockNumber uint64
 
-	// BlockNumber is the hash of the block in which this transaction was skipped or nil.
+	// BlockHash is the hash of the block in which this transaction was skipped or nil.
 	BlockHash *common.Hash
 }
 
@@ -80,21 +80,23 @@ type SkippedTransactionV2 struct {
 	// BlockNumber is the number of the block in which this transaction was skipped.
 	BlockNumber uint64
 
-	// BlockNumber is the hash of the block in which this transaction was skipped or nil.
+	// BlockHash is the hash of the block in which this transaction was skipped or nil.
 	BlockHash *common.Hash
 }
 
 // writeSkippedTransaction writes a skipped transaction to the database.
 func writeSkippedTransaction(db ethdb.KeyValueWriter, tx *types.Transaction, traces *types.BlockTrace, reason string, blockNumber uint64, blockHash *common.Hash) {
+	var err error
 	// workaround: RLP decoding fails if this is nil
 	if blockHash == nil {
 		blockHash = &common.Hash{}
 	}
-	b, err := json.Marshal(traces)
-	if err != nil {
-		log.Crit("Failed to json marshal skipped transaction", "hash", tx.Hash().String(), "err", err)
+	stx := SkippedTransactionV2{Tx: tx, Reason: reason, BlockNumber: blockNumber, BlockHash: blockHash}
+	if traces != nil {
+		if stx.TracesBytes, err = json.Marshal(traces); err != nil {
+			log.Crit("Failed to json marshal skipped transaction", "hash", tx.Hash().String(), "err", err)
+		}
 	}
-	stx := SkippedTransactionV2{Tx: tx, TracesBytes: b, Reason: reason, BlockNumber: blockNumber, BlockHash: blockHash}
 	bytes, err := rlp.EncodeToBytes(stx)
 	if err != nil {
 		log.Crit("Failed to RLP encode skipped transaction", "hash", tx.Hash().String(), "err", err)

core/trace.go

@@ -322,7 +322,8 @@ func (env *TraceEnv) getTxResult(state *state.StateDB, index int, block *types.B
 	// still we have no state root for per tx, only set the head and tail
 	if index == 0 {
 		txStorageTrace.RootBefore = state.GetRootHash()
-	} else if index == len(block.Transactions())-1 {
+	}
+	if index == len(block.Transactions())-1 {
 		txStorageTrace.RootAfter = block.Root()
 	}
 

eth/api.go

@@ -738,9 +738,11 @@ func (api *ScrollAPI) GetSkippedTransaction(ctx context.Context, hash common.Has
 	rpcTx.SkipBlockNumber = (*hexutil.Big)(new(big.Int).SetUint64(stx.BlockNumber))
 	rpcTx.SkipBlockHash = stx.BlockHash
 	if len(stx.TracesBytes) != 0 {
-		if err := json.Unmarshal(stx.TracesBytes, rpcTx.Traces); err != nil {
+		traces := &types.BlockTrace{}
+		if err := json.Unmarshal(stx.TracesBytes, traces); err != nil {
 			return nil, fmt.Errorf("fail to Unmarshal traces for skipped tx, hash: %s, err: %w", hash.String(), err)
 		}
+		rpcTx.Traces = traces
 	}
 	return &rpcTx, nil
 }

miner/worker.go

@@ -1145,6 +1145,7 @@ loop:
 			// However, after `ErrUnknown`, ccc might remain in an
 			// inconsistent state, so we cannot pack more transactions.
 			circuitCapacityReached = true
+			w.checkCurrentTxNumWithCCC(w.current.tcount)
 			break loop
 
 		case (errors.Is(err, circuitcapacitychecker.ErrUnknown) && !tx.IsL1MessageTx()):
@@ -1164,6 +1165,7 @@ loop:
 			// inconsistent state, so we cannot pack more transactions.
 			w.eth.TxPool().RemoveTx(tx.Hash(), true)
 			circuitCapacityReached = true
+			w.checkCurrentTxNumWithCCC(w.current.tcount)
 			break loop
 
 		default:
@@ -1208,6 +1210,17 @@ loop:
 	return false, circuitCapacityReached
 }
 
+func (w *worker) checkCurrentTxNumWithCCC(expected int) {
+	match, got, err := w.circuitCapacityChecker.CheckTxNum(expected)
+	if err != nil {
+		log.Error("failed to CheckTxNum in ccc", "err", err)
+		return
+	}
+	if !match {
+		log.Error("tx count in miner is different with CCC", "w.current.tcount", w.current.tcount, "got", got)
+	}
+}
+
 func (w *worker) collectPendingL1Messages(startIndex uint64) []types.L1MessageTx {
 	maxCount := w.chainConfig.Scroll.L1Config.NumL1MessagesPerBlock
 	return rawdb.ReadL1MessagesFrom(w.eth.ChainDb(), startIndex, maxCount)

params/version.go

@@ -23,8 +23,8 @@ import (
 
 const (
 	VersionMajor = 4         // Major version component of the current release
-	VersionMinor = 3         // Minor version component of the current release
-	VersionPatch = 63        // Patch version component of the current release
+	VersionMinor = 4         // Minor version component of the current release
+	VersionPatch = 5         // Patch version component of the current release
 	VersionMeta  = "sepolia" // Version metadata to append to the version string
 )
 

rollup/circuitcapacitychecker/impl.go

@@ -11,6 +11,7 @@ import "C" //nolint:typecheck
 
 import (
 	"encoding/json"
+	"fmt"
 	"sync"
 	"unsafe"
 
@@ -31,6 +32,7 @@ type CircuitCapacityChecker struct {
 	ID uint64
 }
 
+// NewCircuitCapacityChecker creates a new CircuitCapacityChecker
 func NewCircuitCapacityChecker() *CircuitCapacityChecker {
 	creationMu.Lock()
 	defer creationMu.Unlock()
@@ -39,13 +41,15 @@ func NewCircuitCapacityChecker() *CircuitCapacityChecker {
 	return &CircuitCapacityChecker{ID: uint64(id)}
 }
 
+// Reset resets a CircuitCapacityChecker
 func (ccc *CircuitCapacityChecker) Reset() {
 	ccc.Lock()
 	defer ccc.Unlock()
 
 	C.reset_circuit_capacity_checker(C.uint64_t(ccc.ID))
 }
 
+// ApplyTransaction appends a tx's wrapped BlockTrace into the ccc, and return the accumulated RowConsumption
 func (ccc *CircuitCapacityChecker) ApplyTransaction(traces *types.BlockTrace) (*types.RowConsumption, error) {
 	ccc.Lock()
 	defer ccc.Unlock()
@@ -100,6 +104,7 @@ func (ccc *CircuitCapacityChecker) ApplyTransaction(traces *types.BlockTrace) (*
 	return (*types.RowConsumption)(&result.AccRowUsage.RowUsageDetails), nil
 }
 
+// ApplyBlock gets a block's RowConsumption
 func (ccc *CircuitCapacityChecker) ApplyBlock(traces *types.BlockTrace) (*types.RowConsumption, error) {
 	ccc.Lock()
 	defer ccc.Unlock()
@@ -141,3 +146,26 @@ func (ccc *CircuitCapacityChecker) ApplyBlock(traces *types.BlockTrace) (*types.
 	}
 	return (*types.RowConsumption)(&result.AccRowUsage.RowUsageDetails), nil
 }
+
+// CheckTxNum compares whether the tx_count in ccc match the expected
+func (ccc *CircuitCapacityChecker) CheckTxNum(expected int) (bool, uint64, error) {
+	ccc.Lock()
+	defer ccc.Unlock()
+
+	log.Debug("ccc get_tx_num start", "id", ccc.ID)
+	rawResult := C.get_tx_num(C.uint64_t(ccc.ID))
+	defer func() {
+		C.free(unsafe.Pointer(rawResult))
+	}()
+	log.Debug("ccc get_tx_num end", "id", ccc.ID)
+
+	result := &WrappedTxNum{}
+	if err := json.Unmarshal([]byte(C.GoString(rawResult)), result); err != nil {
+		return false, 0, fmt.Errorf("fail to json unmarshal get_tx_num result, id: %d, err: %w", ccc.ID, err)
+	}
+	if result.Error != "" {
+		return false, 0, fmt.Errorf("fail to get_tx_num in CircuitCapacityChecker, id: %d, err: %w", ccc.ID, result.Error)
+	}
+
+	return result.TxNum == uint64(expected), result.TxNum, nil
+}