Add LogsFilterFunc signature and sample implementation instead of optional validation method

Author: taylanpince

cmd/ethkit/block.go

@@ -291,40 +291,35 @@ func CheckLogs(block *types.Block, provider *ethrpc.Provider, ignoreZeroGasLogs
 	}
 
 	filteredLogs := logs
-	var optCheck []ethutil.LogsBloomCheckFunc
-
 	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()
-		}
-
-		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)
-		})
+		filteredLogs = zeroGasLogsFilter(logs, h, block)
 	}
 
 	fmt.Printf("Block: %d\n", h.Number.Uint64())
 	fmt.Printf("Logs Count: %d\n", len(filteredLogs))
-	fmt.Printf("Match: %v\n", ethutil.ValidateLogsWithBlockHeader(filteredLogs, h, optCheck...))
+	fmt.Printf("Match: %v\n", ethutil.ValidateLogsWithBlockHeader(filteredLogs, h))
 	fmt.Println()
 	fmt.Printf("Calculated Log Bloom: 0x%x\n", ethutil.ConvertLogsToBloom(filteredLogs).Bytes())
 	fmt.Println()
 	fmt.Printf("Header Log Bloom: 0x%x\n", h.Bloom.Bytes())
 	fmt.Println()
 }
+
+// zeroGasLogsFilter removes logs from transactions whose gas price is zero
+// (HyperEVM system transactions).
+func zeroGasLogsFilter(ls []types.Log, _ *types.Header, block *types.Block) []types.Log {
+	gasPriceByTx := make(map[common.Hash]*big.Int, len(block.Transactions()))
+	for _, tx := range block.Transactions() {
+		gasPriceByTx[tx.Hash()] = tx.GasPrice()
+	}
+
+	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
+}

ethutil/validate_logs_with_block.go

@@ -6,19 +6,17 @@ import (
 	"github.com/0xsequence/ethkit/go-ethereum/core/types"
 )
 
-// LogsBloomCheckFunc allows callers to override how logs bloom validation is performed.
+// LogsBloomCheckFunc is the shape of a logs bloom validation function.
 // 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, 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)
-	}
+// LogsFilterFunc transforms or filters logs before validation.
+// The block is provided for cases where filtering depends on transaction data.
+type LogsFilterFunc func(logs []types.Log, header *types.Header, block *types.Block) []types.Log
 
+// ValidateLogsWithBlockHeader validates that the logs come from the given block
+// by comparing the calculated bloom against the header bloom.
+func ValidateLogsWithBlockHeader(logs []types.Log, header *types.Header) bool {
 	return bytes.Equal(ConvertLogsToBloom(logs).Bytes(), header.Bloom.Bytes())
 }
 

ethutil/validate_logs_with_block_test.go

@@ -30,7 +30,7 @@ func TestValidateLogsWithBlockHeader(t *testing.T) {
 	require.True(t, ValidateLogsWithBlockHeader(logs, header))
 }
 
-func TestValidateLogsWithBlockHeaderWithCustomCheck(t *testing.T) {
+func TestValidateLogsWithBlockHeaderWithFilter(t *testing.T) {
 	logs := []types.Log{
 		{
 			Address: common.HexToAddress("0x0000000000000000000000000000000000000001"),
@@ -48,11 +48,16 @@ func TestValidateLogsWithBlockHeaderWithCustomCheck(t *testing.T) {
 	require.True(t, ValidateLogsWithBlockHeader(logs, headerFull))
 	require.False(t, ValidateLogsWithBlockHeader(logs, headerFiltered))
 
-	customCheck := func(ls []types.Log, header *types.Header) bool {
+	var filter LogsFilterFunc = func(ls []types.Log, _ *types.Header, _ *types.Block) []types.Log {
 		// Ignore the first log (e.g., system tx) and validate bloom against the remainder.
-		filtered := ls[1:]
-		return bytes.Equal(ConvertLogsToBloom(filtered).Bytes(), header.Bloom.Bytes())
+		return ls[1:]
 	}
+	filteredLogs := filter(logs, headerFiltered, nil)
 
-	require.True(t, ValidateLogsWithBlockHeader(logs, headerFiltered, customCheck))
+	require.True(t, ValidateLogsWithBlockHeader(filteredLogs, headerFiltered))
+
+	var customCheck LogsBloomCheckFunc = func(ls []types.Log, header *types.Header) bool {
+		return bytes.Equal(ConvertLogsToBloom(ls[1:]).Bytes(), header.Bloom.Bytes())
+	}
+	require.True(t, customCheck(logs, headerFiltered))
 }