Fuzz Network Test Framework

.gitignore

@@ -30,3 +30,7 @@ go.work.sum
 
 .DS_Store
 .idea/
+
+# tmp folder
+
+/tmp

epoch_test.go

@@ -1727,6 +1727,10 @@ func TestQuorum(t *testing.T) {
 			n: 12, f: 3,
 			q: 8,
 		},
+		{
+			n: 7, f: 2,
+			q: 5,
+		},
 	} {
 		t.Run(fmt.Sprintf("%d", testCase.n), func(t *testing.T) {
 			require.Equal(t, testCase.q, Quorum(testCase.n))

fuzz_network_test.go

@@ -0,0 +1,15 @@
+package simplex_test
+
+import (
+	"testing"
+
+	"github.com/ava-labs/simplex/testutil/random_network"
+)
+
+func TestNetworkSimpleFuzz(t *testing.T) {
+	config := random_network.DefaultFuzzConfig()
+	config.RandomSeed = 1770220909588
+	network := random_network.NewNetwork(config, t)
+	network.Run()
+	network.PrintStatus()
+}

testutil/logger.go

@@ -5,6 +5,7 @@ package testutil
 
 import (
 	"fmt"
+	"io"
 	"os"
 	"strings"
 	"testing"
@@ -96,13 +97,16 @@ func (tl *TestLogger) Error(msg string, fields ...zap.Field) {
 }
 
 func MakeLogger(t *testing.T, node ...int) *TestLogger {
-	return MakeLoggerWithFile(t, nil, node...)
+	// Preserve existing behavior: logs to stdout by default.
+	return MakeLoggerWithFile(t, nil, true, node...)
 }
 
-// MakeLoggerWithFile creates a TestLogger that optionally writes to a file in addition to stdout.
-// If fileWriter is nil, logs only to stdout (same as MakeLogger).
-// If fileWriter is provided, logs to both stdout and the file.
-func MakeLoggerWithFile(t *testing.T, fileWriter zapcore.WriteSyncer, node ...int) *TestLogger {
+// MakeLoggerWithFile creates a TestLogger that can write to a file and optionally to stdout.
+// - If writeStdout is true, logs may be written to stdout.
+// - If fileWriter is non-nil, logs may be written to that fileWriter.
+// - If both are enabled, logs go to both.
+// - If neither is enabled, logs are discarded.
+func MakeLoggerWithFile(t *testing.T, fileWriter zapcore.WriteSyncer, writeStdout bool, node ...int) *TestLogger {
 	defaultEncoderConfig := zapcore.EncoderConfig{
 		TimeKey:        "timestamp",
 		LevelKey:       "level",
@@ -120,28 +124,48 @@ func MakeLoggerWithFile(t *testing.T, fileWriter zapcore.WriteSyncer, node ...in
 	config.EncodeTime = zapcore.TimeEncoderOfLayout("[01-02|15:04:05.000]")
 	config.ConsoleSeparator = " "
 
-	// Create stdout encoder
-	stdoutEncoder := zapcore.NewConsoleEncoder(config)
-	if strings.ToLower(os.Getenv("LOG_LEVEL")) == "info" {
-		stdoutEncoder = &DebugSwallowingEncoder{consoleEncoder: stdoutEncoder, ObjectEncoder: stdoutEncoder, pool: buffer.NewPool()}
-	}
-
 	atomicLevel := zap.NewAtomicLevelAt(zapcore.DebugLevel)
 
-	// Create stdout core
-	stdoutCore := zapcore.NewCore(stdoutEncoder, zapcore.AddSync(os.Stdout), atomicLevel)
+	var cores []zapcore.Core
 
-	// If file writer is provided, create a tee core with both stdout and file
-	var core zapcore.Core
+	// Stdout core only if explicitly enabled
+	if writeStdout {
+		stdoutEncoder := zapcore.NewConsoleEncoder(config)
+		if strings.ToLower(os.Getenv("LOG_LEVEL")) == "info" {
+			stdoutEncoder = &DebugSwallowingEncoder{
+				consoleEncoder: stdoutEncoder,
+				ObjectEncoder:  stdoutEncoder,
+				pool:           buffer.NewPool(),
+			}
+		}
+		stdoutCore := zapcore.NewCore(stdoutEncoder, zapcore.AddSync(os.Stdout), atomicLevel)
+		cores = append(cores, stdoutCore)
+	}
+
+	// File core only if provided
 	if fileWriter != nil {
 		fileEncoder := zapcore.NewConsoleEncoder(config)
 		if strings.ToLower(os.Getenv("LOG_LEVEL")) == "info" {
-			fileEncoder = &DebugSwallowingEncoder{consoleEncoder: fileEncoder, ObjectEncoder: fileEncoder, pool: buffer.NewPool()}
+			fileEncoder = &DebugSwallowingEncoder{
+				consoleEncoder: fileEncoder,
+				ObjectEncoder:  fileEncoder,
+				pool:           buffer.NewPool(),
+			}
 		}
 		fileCore := zapcore.NewCore(fileEncoder, fileWriter, atomicLevel)
-		core = zapcore.NewTee(stdoutCore, fileCore)
-	} else {
-		core = stdoutCore
+		cores = append(cores, fileCore)
+	}
+
+	// If neither stdout nor file enabled, discard logs.
+	var core zapcore.Core
+	switch len(cores) {
+	case 0:
+		discardEncoder := zapcore.NewConsoleEncoder(config)
+		core = zapcore.NewCore(discardEncoder, zapcore.AddSync(io.Discard), atomicLevel)
+	case 1:
+		core = cores[0]
+	default:
+		core = zapcore.NewTee(cores...)
 	}
 
 	logger := zap.New(core, zap.AddCaller())
@@ -152,16 +176,15 @@ func MakeLoggerWithFile(t *testing.T, fileWriter zapcore.WriteSyncer, node ...in
 
 	traceVerboseLogger := zap.New(core, zap.AddCaller(), zap.AddCallerSkip(1))
 	traceVerboseLogger = traceVerboseLogger.With(zap.String("test", t.Name()))
-
 	if len(node) > 0 {
 		traceVerboseLogger = traceVerboseLogger.With(zap.Int("myNodeID", node[0]))
 	}
 
-	l := &TestLogger{Logger: logger, traceVerboseLogger: traceVerboseLogger,
-		atomicLevel: atomicLevel,
+	return &TestLogger{
+		Logger:             logger,
+		traceVerboseLogger: traceVerboseLogger,
+		atomicLevel:        atomicLevel,
 	}
-
-	return l
 }
 
 type DebugSwallowingEncoder struct {

testutil/random_network/block.go

@@ -0,0 +1,143 @@
+// Copyright (C) 2019-2025, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package random_network
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/asn1"
+	"fmt"
+
+	"github.com/ava-labs/simplex"
+)
+
+var _ simplex.Block = (*Block)(nil)
+
+type Block struct {
+	blacklist simplex.Blacklist
+
+	// contents
+	txs []*TX
+
+	// protocol metadata
+	metadata simplex.ProtocolMetadata
+	digest   simplex.Digest
+
+	// mempool access
+	mempool *Mempool
+}
+
+func NewBlock(metadata simplex.ProtocolMetadata, blacklist simplex.Blacklist, mempool *Mempool, txs []*TX) *Block {
+	b := &Block{
+		mempool:   mempool,
+		txs:       txs,
+		metadata:  metadata,
+		blacklist: blacklist,
+	}
+
+	b.ComputeAndSetDigest()
+	return b
+}
+
+func (b *Block) Verify(ctx context.Context) (simplex.VerifiedBlock, error) {
+	return b, b.mempool.VerifyBlock(ctx, b)
+}
+
+func (b *Block) Blacklist() simplex.Blacklist {
+	return b.blacklist
+}
+
+func (b *Block) BlockHeader() simplex.BlockHeader {
+	return simplex.BlockHeader{
+		ProtocolMetadata: b.metadata,
+		Digest:           b.digest,
+	}
+}
+
+type encodedBlock struct {
+	ProtocolMetadata []byte
+	TXs              []asn1TX
+	Blacklist        []byte
+}
+
+func (b *Block) Bytes() ([]byte, error) {
+	mdBytes := b.metadata.Bytes()
+
+	var asn1TXs []asn1TX
+	for _, tx := range b.txs {
+		asn1TXs = append(asn1TXs, asn1TX{ID: tx.ID[:]})
+	}
+
+	blacklistBytes := b.blacklist.Bytes()
+
+	encodedB := encodedBlock{
+		ProtocolMetadata: mdBytes,
+		TXs:              asn1TXs,
+		Blacklist:        blacklistBytes,
+	}
+
+	return asn1.Marshal(encodedB)
+}
+
+func (b *Block) containsTX(txID txID) bool {
+	for _, tx := range b.txs {
+		if tx.ID == txID {
+			return true
+		}
+	}
+	return false
+}
+
+func (b *Block) ComputeAndSetDigest() {
+	var bb bytes.Buffer
+	tbBytes, err := b.Bytes()
+	if err != nil {
+		panic(fmt.Sprintf("failed to serialize test block: %v", err))
+	}
+
+	bb.Write(tbBytes)
+	b.digest = sha256.Sum256(bb.Bytes())
+}
+
+type BlockDeserializer struct {
+	mempool *Mempool
+}
+
+var _ simplex.BlockDeserializer = (*BlockDeserializer)(nil)
+
+func (bd *BlockDeserializer) DeserializeBlock(ctx context.Context, buff []byte) (simplex.Block, error) {
+	var encodedBlock encodedBlock
+	_, err := asn1.Unmarshal(buff, &encodedBlock)
+	if err != nil {
+		return nil, err
+	}
+
+	md, err := simplex.ProtocolMetadataFromBytes(encodedBlock.ProtocolMetadata)
+	if err != nil {
+		return nil, err
+	}
+
+	var blacklist simplex.Blacklist
+	if err := blacklist.FromBytes(encodedBlock.Blacklist); err != nil {
+		return nil, err
+	}
+
+	txs := make([]*TX, len(encodedBlock.TXs))
+	for i, asn1Tx := range encodedBlock.TXs {
+		tx := asn1Tx.toTX()
+		txs[i] = tx
+	}
+
+	b := &Block{
+		metadata:  *md,
+		txs:       txs,
+		blacklist: blacklist,
+		mempool:   bd.mempool,
+	}
+
+	b.ComputeAndSetDigest()
+
+	return b, nil
+}

testutil/random_network/config.go

@@ -0,0 +1,54 @@
+// Copyright (C) 2019-2025, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package random_network
+
+import "time"
+
+type FuzzConfig struct {
+	// The minimum and maximum number of nodes in the network. Default is between 3 and 10.
+	MinNodes int
+	MaxNodes int
+
+	// The probability that a transaction verification will fail. Default is .1%.
+	TxVerificationFailure float64
+
+	// The minimum and maximum number of transactions per block. Default is between 5 and 20.
+	MinTxsPerBlock int
+	MaxTxsPerBlock int
+
+	// The number of blocks that must be finalized before ending the fuzz test. Default is 100.
+	NumFinalizedBlocks int
+
+	RandomSeed int64
+
+	// Chance that a node will be randomly crashed. Default is 10%.
+	NodeCrashPercentage float64
+
+	// Chance that a crashed node will be restarted. Default is 50%.
+	NodeRecoverPercentage float64
+
+	// Amount to advance the time by. Default is 1000ms.
+	AdvanceTimeTickAmount time.Duration
+
+	// Creates main.log for network logs and {nodeID-short}.log for each node.
+	// NodeID is represented as a 16-character hex string (first 8 bytes).
+	// Default is "tmp".
+	LogDirectory string
+}
+
+func DefaultFuzzConfig() *FuzzConfig {
+	return &FuzzConfig{
+		MinNodes:              3,
+		MaxNodes:              10,
+		TxVerificationFailure: .001,
+		MinTxsPerBlock:        5,
+		MaxTxsPerBlock:        20,
+		NumFinalizedBlocks:    100,
+		RandomSeed:            time.Now().UnixMilli(),
+		NodeCrashPercentage:   0.1,
+		NodeRecoverPercentage: 0.5,
+		AdvanceTimeTickAmount: 1000 * time.Millisecond,
+		LogDirectory:          "tmp",
+	}
+}