Update ethutil with optional LogsBloomCheckFunc

Author: taylanpince

cmd/ethkit/block.go

@@ -18,11 +18,12 @@ import (
 )
 
 const (
-	flagBlockField     = "field"
-	flagBlockFull      = "full"
-	flagBlockRpcUrl    = "rpc-url"
-	flagBlockJson      = "json"
-	flagBlockCheckLogs = "check-logs-bloom"
+	flagBlockField             = "field"
+	flagBlockFull              = "full"
+	flagBlockRpcUrl            = "rpc-url"
+	flagBlockJson              = "json"
+	flagBlockCheckLogs         = "check-logs-bloom"
+	flagBlockIgnoreZeroGasLogs = "ignore-zero-gas-logs"
 )
 
 func init() {
@@ -48,6 +49,7 @@ func NewBlockCmd() *cobra.Command {
 	cmd.Flags().StringP(flagBlockRpcUrl, "r", "", "The RPC endpoint to the blockchain node to interact with")
 	cmd.Flags().BoolP(flagBlockJson, "j", false, "Print the block as JSON")
 	cmd.Flags().Bool(flagBlockCheckLogs, false, "Check logs bloom against the block header reported value")
+	cmd.Flags().Bool(flagBlockIgnoreZeroGasLogs, false, "Ignore logs from transactions with gas price 0 when checking bloom (HyperEVM system txs)")
 
 	return cmd
 }
@@ -74,6 +76,10 @@ func (c *block) Run(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+	fIgnoreZeroGasLogs, err := cmd.Flags().GetBool(flagBlockIgnoreZeroGasLogs)
+	if err != nil {
+		return err
+	}
 
 	if _, err = url.ParseRequestURI(fRpc); err != nil {
 		return errors.New("error: please provide a valid rpc url (e.g. https://nodes.sequence.app/mainnet)")
@@ -115,7 +121,7 @@ func (c *block) Run(cmd *cobra.Command, args []string) error {
 	}
 
 	if fBlockCheckLogs {
-		CheckLogs(block, provider)
+		CheckLogs(block, provider, fIgnoreZeroGasLogs)
 	}
 
 	fmt.Fprintln(cmd.OutOrStdout(), obj)
@@ -268,7 +274,7 @@ func (b *Block) String() string {
 }
 
 // CheckLogs verifies that the logs bloom and logs hash in the block header match the actual logs
-func CheckLogs(block *types.Block, provider *ethrpc.Provider) {
+func CheckLogs(block *types.Block, provider *ethrpc.Provider, ignoreZeroGasLogs bool) {
 	h, err := provider.HeaderByNumber(context.Background(), block.Number())
 
 	if err != nil {
@@ -284,24 +290,38 @@ func CheckLogs(block *types.Block, provider *ethrpc.Provider) {
 		fmt.Println("Error getting logs:", err)
 	}
 
-	// Build a quick lookup of tx hash -> gas price so we can drop system (zero price) tx logs.
-	gasPriceByTx := make(map[common.Hash]*big.Int, len(block.Transactions()))
-	for _, tx := range block.Transactions() {
-		gasPriceByTx[tx.Hash()] = tx.GasPrice()
-	}
+	filteredLogs := logs
+	var optCheck []ethutil.LogsBloomCheckFunc
 
-	filteredLogs := make([]types.Log, 0, len(logs))
-	for _, log := range logs {
-		if gp, ok := gasPriceByTx[log.TxHash]; ok && gp.Sign() == 0 {
-			// HyperEVM system tx (gas price = 0) — ignore for bloom validation.
-			continue
+	if ignoreZeroGasLogs {
+		// Build a quick lookup of tx hash -> gas price so we can drop system (zero price) tx logs.
+		gasPriceByTx := make(map[common.Hash]*big.Int, len(block.Transactions()))
+		for _, tx := range block.Transactions() {
+			gasPriceByTx[tx.Hash()] = tx.GasPrice()
 		}
-		filteredLogs = append(filteredLogs, log)
+
+		filter := func(ls []types.Log) []types.Log {
+			out := make([]types.Log, 0, len(ls))
+			for _, l := range ls {
+				if gp, ok := gasPriceByTx[l.TxHash]; ok && gp.Sign() == 0 {
+					// HyperEVM system tx (gas price = 0) — ignore for bloom validation.
+					continue
+				}
+				out = append(out, l)
+			}
+			return out
+		}
+
+		filteredLogs = filter(logs)
+
+		optCheck = append(optCheck, func(ls []types.Log, header *types.Header) bool {
+			return ethutil.ValidateLogsWithBlockHeader(filter(ls), header)
+		})
 	}
 
 	fmt.Printf("Block: %d\n", h.Number.Uint64())
-	fmt.Printf("Logs Count (after filtering zero gas price txs): %d\n", len(filteredLogs))
-	fmt.Printf("Match: %v\n", ethutil.ValidateLogsWithBlockHeader(filteredLogs, h))
+	fmt.Printf("Logs Count: %d\n", len(filteredLogs))
+	fmt.Printf("Match: %v\n", ethutil.ValidateLogsWithBlockHeader(filteredLogs, h, optCheck...))
 	fmt.Println()
 	fmt.Printf("Calculated Log Bloom: 0x%x\n", logsToBloom(filteredLogs).Bytes())
 	fmt.Println()

ethutil/validate_logs_with_block.go

@@ -6,11 +6,20 @@ import (
 	"github.com/0xsequence/ethkit/go-ethereum/core/types"
 )
 
+// LogsBloomCheckFunc allows callers to override how logs bloom validation is performed.
+// Returning true means the logs match the header; false means they do not.
+type LogsBloomCheckFunc func(logs []types.Log, header *types.Header) bool
+
 // ValidateLogsWithBlockHeader validates that the logs comes from given block.
 // If the list of logs is not complete or the logs are not from the block, it
 // will return false.
-func ValidateLogsWithBlockHeader(logs []types.Log, header *types.Header) bool {
-	return bytes.Compare(logsToBloom(logs).Bytes(), header.Bloom.Bytes()) == 0
+func ValidateLogsWithBlockHeader(logs []types.Log, header *types.Header, optLogsBloomCheck ...LogsBloomCheckFunc) bool {
+	// Allow callers to override the check logic (e.g. filtering certain logs).
+	if len(optLogsBloomCheck) > 0 && optLogsBloomCheck[0] != nil {
+		return optLogsBloomCheck[0](logs, header)
+	}
+
+	return bytes.Equal(logsToBloom(logs).Bytes(), header.Bloom.Bytes())
 }
 
 func logsToBloom(logs []types.Log) types.Bloom {

ethutil/validate_logs_with_block_test.go

@@ -1,12 +1,15 @@
 package ethutil
 
 import (
+	"bytes"
 	"context"
 	"math/big"
 	"testing"
 
 	"github.com/0xsequence/ethkit/ethrpc"
 	"github.com/0xsequence/ethkit/go-ethereum"
+	"github.com/0xsequence/ethkit/go-ethereum/common"
+	"github.com/0xsequence/ethkit/go-ethereum/core/types"
 	"github.com/stretchr/testify/require"
 )
 
@@ -26,3 +29,30 @@ func TestValidateLogsWithBlockHeader(t *testing.T) {
 
 	require.True(t, ValidateLogsWithBlockHeader(logs, header))
 }
+
+func TestValidateLogsWithBlockHeaderWithCustomCheck(t *testing.T) {
+	logs := []types.Log{
+		{
+			Address: common.HexToAddress("0x0000000000000000000000000000000000000001"),
+			Topics:  []common.Hash{common.HexToHash("0x01")},
+		},
+		{
+			Address: common.HexToAddress("0x0000000000000000000000000000000000000002"),
+			Topics:  []common.Hash{common.HexToHash("0x02")},
+		},
+	}
+
+	headerFull := &types.Header{Bloom: logsToBloom(logs)}
+	headerFiltered := &types.Header{Bloom: logsToBloom(logs[1:])}
+
+	require.True(t, ValidateLogsWithBlockHeader(logs, headerFull))
+	require.False(t, ValidateLogsWithBlockHeader(logs, headerFiltered))
+
+	customCheck := func(ls []types.Log, header *types.Header) bool {
+		// Ignore the first log (e.g., system tx) and validate bloom against the remainder.
+		filtered := ls[1:]
+		return bytes.Equal(logsToBloom(filtered).Bytes(), header.Bloom.Bytes())
+	}
+
+	require.True(t, ValidateLogsWithBlockHeader(logs, headerFiltered, customCheck))
+}