consensus/dbft: forbid new transaction types in envelope verification

Author: txhsl

antimev/envelope.go

@@ -51,7 +51,7 @@ var (
 // IsEnvelope checks whether a transaction is an Envelope transaction. The criteria
 // include receiver's address, data prefix and data length check.
 func IsEnvelope(tx *types.Transaction) bool {
-	return IsEnvelopeToAddress(tx.To()) && IsEnvelopeData(tx.Data())
+	return (tx.Type() != types.BlobTxType && tx.Type() != types.SetCodeTxType) && IsEnvelopeToAddress(tx.To()) && IsEnvelopeData(tx.Data())
 }
 
 // IsEnvelopeToAddress checks whether an address pointer has the expected value for

consensus/dbft/dbft.go

@@ -926,13 +926,19 @@ func (c *DBFT) verifyPreBlockCb(b dbft.PreBlock[common.Hash]) bool {
 	}
 	ethBlock := dbftBlock.ToEthBlock()
 
-	errs := c.staticPool.Add(dbftBlock.transactions, false)
+	// Only take legacy pool transactions.
+	legacyTxs := make(types.Transactions, 0, len(dbftBlock.transactions))
+	for _, tx := range dbftBlock.transactions {
+		if tx.Type() != types.BlobTxType {
+			legacyTxs = append(legacyTxs, tx)
+		}
+	}
+	errs := c.staticPool.Add(legacyTxs, false)
 	c.staticPool.ResetStatic()
 	for i, err := range errs {
 		if err != nil {
 			log.Warn("proposed PreBlock has invalid transaction",
-				"index", i,
-				"hash", dbftBlock.transactions[i].Hash(),
+				"hash", legacyTxs[i].Hash(),
 				"error", err,
 			)
 			return false
@@ -1174,8 +1180,12 @@ func (c *DBFT) processPreBlockCb(b dbft.PreBlock[common.Hash]) error {
 		}
 		// No need to reinitialize static pool since it was already initialized in verifyPreBlockCb.
 		// Reset the static pool after processing all transactions.
-		for i := range pre.transactions {
+		for i, originTx := range pre.transactions {
 			var isEnvelope = j < len(pre.envelopesData) && pre.envelopesData[j].index == i
+			if originTx.Type() == types.BlobTxType { // Skip blob transactions.
+				txx[i] = originTx
+				continue
+			}
 			if !isEnvelope || // pre.transactions[i] is not an envelope, use it as-is.
 				decryptedTxsBytes[j] == nil { // pre.transactions[i] is Envelope, but its content failed to be decrypted, use Envelope as-is.
 				var reason string
@@ -1189,7 +1199,7 @@ func (c *DBFT) processPreBlockCb(b dbft.PreBlock[common.Hash]) error {
 				}
 			}
 			log.Info("Envelope data decrypted",
-				"envelope hash", pre.transactions[i].Hash(),
+				"envelope hash", originTx.Hash(),
 				"envelope index", i,
 				"data", hex.EncodeToString(decryptedTxsBytes[j]))
 			var decryptedTx = new(types.Transaction)
@@ -1201,7 +1211,7 @@ func (c *DBFT) processPreBlockCb(b dbft.PreBlock[common.Hash]) error {
 					break
 				}
 			}
-			err = c.validateDecryptedTx(parent, decryptedTx, pre.transactions[i], receipts[i])
+			err = c.validateDecryptedTx(parent, decryptedTx, originTx, receipts[i])
 			if err != nil {
 				if fallbackToEnvelope(i, true, fmt.Sprintf("decrypted transaction verification failed: %s", err)) {
 					continue
@@ -1295,6 +1305,11 @@ func (c *DBFT) initStaticPool(parent *types.Header, state *state.StateDB) error
 
 // validateDecryptedTx checks the validity of the transaction to determine whether the outer envelope transaction should be replaced.
 func (c *DBFT) validateDecryptedTx(head *types.Header, decryptedTx *types.Transaction, envelope *types.Transaction, envelopeReceipt *types.Receipt) error {
+	// Make sure the transaction type is supported by legacy tx pool
+	if decryptedTx.Type() == types.BlobTxType {
+		return fmt.Errorf("decryptedTx has unsupported type: %v", decryptedTx.Type())
+	}
+
 	// Make sure the transaction is signed properly and has the same sender and nonce with envelope
 	if decryptedTx.Nonce() != envelope.Nonce() {
 		return fmt.Errorf("decryptedTx nonce mismatch: decryptedNonce %v, envelopeNonce %v", decryptedTx.Nonce(), envelope.Nonce())