test(fuzz): add fuzz tests for CompactToBig and loadHeadersFromFile

Author: mrz1836

pkg/chaintracks/chainwork_fuzz_test.go

@@ -0,0 +1,96 @@
+package chaintracks
+
+import (
+	"testing"
+)
+
+// FuzzCompactToBig tests CompactToBig with random uint32 values
+// to ensure it never panics and always returns a valid big.Int.
+func FuzzCompactToBig(f *testing.F) {
+	// Seed corpus with known interesting values
+	f.Add(uint32(0x1d00ffff)) // genesis block mainnet
+	f.Add(uint32(0x1b0404cb)) // typical difficulty
+	f.Add(uint32(0x00000000)) // zero
+	f.Add(uint32(0xffffffff)) // max uint32
+	f.Add(uint32(0x01000000)) // exponent = 1
+	f.Add(uint32(0x02000000)) // exponent = 2
+	f.Add(uint32(0x03000000)) // exponent = 3
+	f.Add(uint32(0x00800000)) // sign bit set, exponent = 0
+	f.Add(uint32(0x01800000)) // sign bit set, exponent = 1
+
+	f.Fuzz(func(t *testing.T, compact uint32) {
+		// Should never panic
+		result := CompactToBig(compact)
+
+		// Result should never be nil
+		if result == nil {
+			t.Fatal("CompactToBig returned nil")
+		}
+
+		// Result should be a valid big.Int
+		if result.BitLen() < 0 {
+			t.Errorf("CompactToBig(%x) returned invalid big.Int", compact)
+		}
+
+		// Verify sign bit handling
+		isNegative := compact&0x00800000 != 0
+		if isNegative && result.Sign() > 0 {
+			t.Errorf("CompactToBig(%x) should be negative but got sign %d", compact, result.Sign())
+		}
+
+		// For zero mantissa, result should be zero
+		mantissa := compact & 0x007fffff
+		if mantissa == 0 && result.Sign() != 0 {
+			t.Errorf("CompactToBig(%x) with zero mantissa should return zero, got %v", compact, result)
+		}
+	})
+}
+
+// FuzzChainWorkFromHex tests ChainWorkFromHex with random strings
+// to ensure it handles invalid input gracefully without panicking.
+func FuzzChainWorkFromHex(f *testing.F) {
+	// Seed corpus with valid and invalid hex strings
+	f.Add("0000000000000000000000000000000000000000000000000000000000003039")
+	f.Add("1234567890abcdef")
+	f.Add("invalid")
+	f.Add("")
+	f.Add("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
+	f.Add("000000000000000000000000000000000000000000000000000000000000000g") // invalid hex char
+	f.Add("0x1234")                                                           // 0x prefix
+	f.Add("   1234   ")                                                       // whitespace
+	f.Add("\n1234\n")                                                         // newlines
+	f.Add("😀")                                                                // unicode
+	f.Add(string([]byte{0x00, 0x01, 0x02}))                                   // control chars
+
+	f.Fuzz(func(t *testing.T, hexStr string) {
+		// Should never panic
+		result, err := ChainWorkFromHex(hexStr)
+
+		// If no error, result should not be nil
+		if err == nil && result == nil {
+			t.Fatal("ChainWorkFromHex returned nil without error")
+		}
+
+		// If error, result should be nil
+		if err != nil && result != nil {
+			t.Errorf("ChainWorkFromHex returned non-nil result with error: %v", err)
+		}
+
+		// If successful, result should be a valid big.Int
+		if err == nil {
+			if result.BitLen() < 0 {
+				t.Errorf("ChainWorkFromHex(%q) returned invalid big.Int", hexStr)
+			}
+
+			// Round-trip test: convert back to hex and parse again
+			hexOut := result.Text(16)
+			result2, err2 := ChainWorkFromHex(hexOut)
+			if err2 != nil {
+				t.Errorf("Round-trip failed for %q: %v", hexStr, err2)
+			}
+			if result.Cmp(result2) != 0 {
+				t.Errorf("Round-trip mismatch for %q: %v != %v", hexStr, result, result2)
+			}
+		}
+	})
+}

pkg/chaintracks/loader_fuzz_test.go

@@ -0,0 +1,101 @@
+package chaintracks
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// FuzzLoadHeadersFromFile tests loadHeadersFromFile with random binary data
+// to ensure it handles malformed header files gracefully without panicking.
+func FuzzLoadHeadersFromFile(f *testing.F) {
+	// Seed corpus with interesting binary patterns
+
+	// Empty file
+	f.Add([]byte{})
+
+	// Single valid-looking header (80 bytes of zeros)
+	validHeader := make([]byte, 80)
+	f.Add(validHeader)
+
+	// Two headers (160 bytes)
+	twoHeaders := make([]byte, 160)
+	f.Add(twoHeaders)
+
+	// Not a multiple of 80 (79 bytes)
+	f.Add(make([]byte, 79))
+
+	// Not a multiple of 80 (81 bytes)
+	f.Add(make([]byte, 81))
+
+	// Not a multiple of 80 (159 bytes)
+	f.Add(make([]byte, 159))
+
+	// Large file (1000 headers = 80,000 bytes)
+	largeFile := make([]byte, 80*1000)
+	f.Add(largeFile)
+
+	// Random pattern (240 bytes = 3 headers worth)
+	randomPattern := []byte{
+		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	}
+	f.Add(randomPattern)
+
+	// All 0xFF bytes (80 bytes)
+	allOnes := make([]byte, 80)
+	for i := range allOnes {
+		allOnes[i] = 0xFF
+	}
+	f.Add(allOnes)
+
+	f.Fuzz(func(t *testing.T, data []byte) {
+		// Create a temporary file with the fuzzed data
+		tmpDir := t.TempDir()
+		tmpFile := filepath.Join(tmpDir, "fuzz.headers")
+
+		err := os.WriteFile(tmpFile, data, 0o600)
+		require.NoError(t, err, "Failed to write temp file")
+
+		// Should never panic
+		headers, err := loadHeadersFromFile(tmpFile)
+
+		// Validate invariants based on input
+		dataLen := len(data)
+
+		// If data length is not a multiple of 80, should return error
+		if dataLen%80 != 0 {
+			require.Error(t, err, "Expected error for non-80-byte-aligned data")
+			require.Nil(t, headers, "Headers should be nil on error")
+			require.ErrorIs(t, err, ErrInvalidFileSize, "Should return ErrInvalidFileSize")
+			return
+		}
+
+		// If data length is a multiple of 80, it may succeed or fail depending on header validity
+		expectedHeaderCount := dataLen / 80
+
+		if err != nil {
+			// Error is acceptable if header parsing fails
+			require.Nil(t, headers, "Headers should be nil when error is returned")
+		} else {
+			// Success: validate the returned headers
+			require.NotNil(t, headers, "Headers should not be nil on success")
+			require.Len(t, headers, expectedHeaderCount, "Header count mismatch")
+
+			// Verify each header is not nil
+			for i, header := range headers {
+				require.NotNil(t, header, "Header at index %d should not be nil", i)
+			}
+		}
+	})
+}