Merge branch 'develop' into opstack-docs

op-e2e/geth.go

@@ -53,7 +53,7 @@ func waitForL1OriginOnL2(l1BlockNum uint64, client *ethclient.Client, timeout ti
 			}
 
 		case err := <-headSub.Err():
-			return nil, fmt.Errorf("Error in head subscription: %w", err)
+			return nil, fmt.Errorf("error in head subscription: %w", err)
 		case <-timeoutCh:
 			return nil, errors.New("timeout")
 		}
@@ -101,7 +101,7 @@ func waitForBlock(number *big.Int, client *ethclient.Client, timeout time.Durati
 				return client.BlockByNumber(ctx, number)
 			}
 		case err := <-headSub.Err():
-			return nil, fmt.Errorf("Error in head subscription: %w", err)
+			return nil, fmt.Errorf("error in head subscription: %w", err)
 		case <-timeoutCh:
 			return nil, errors.New("timeout")
 		}

op-e2e/setup.go

@@ -464,7 +464,7 @@ func (cfg SystemConfig) Start() (*System, error) {
 		if p, ok := p2pNodes[name]; ok {
 			c.P2P = p
 
-			if c.Driver.SequencerEnabled {
+			if c.Driver.SequencerEnabled && c.P2PSigner == nil {
 				c.P2PSigner = &p2p.PreparedSigner{Signer: p2p.NewLocalSigner(cfg.Secrets.SequencerP2P)}
 			}
 		}

op-e2e/system_test.go

@@ -28,7 +28,10 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
+	rollupNode "github.com/ethereum-optimism/optimism/op-node/node"
+	"github.com/ethereum-optimism/optimism/op-node/p2p"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/driver"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum-optimism/optimism/op-node/withdrawals"
@@ -590,7 +593,7 @@ func TestSystemMockP2P(t *testing.T) {
 
 	// connect the nodes
 	cfg.P2PTopology = map[string][]string{
-		"verifier": []string{"sequencer"},
+		"verifier": {"sequencer"},
 	}
 
 	var published, received []common.Hash
@@ -646,6 +649,189 @@ func TestSystemMockP2P(t *testing.T) {
 	require.Contains(t, received, receiptVerif.BlockHash)
 }
 
+// TestSystemMockPeerScoring sets up a L1 Geth node, a rollup node, and a L2 geth node and then confirms that
+// the nodes can sync L2 blocks before they are confirmed on L1.
+func TestSystemMockPeerScoring(t *testing.T) {
+	parallel(t)
+	if !verboseGethNodes {
+		log.Root().SetHandler(log.DiscardHandler())
+	}
+
+	cfg := DefaultSystemConfig(t)
+	// slow down L1 blocks so we can see the L2 blocks arrive well before the L1 blocks do.
+	// Keep the seq window small so the L2 chain is started quick
+	cfg.DeployConfig.L1BlockTime = 10
+
+	// Append additional nodes to the system to construct a dense p2p network
+	cfg.Nodes["verifier2"] = &rollupNode.Config{
+		Driver: driver.Config{
+			VerifierConfDepth:  0,
+			SequencerConfDepth: 0,
+			SequencerEnabled:   false,
+		},
+		L1EpochPollInterval: time.Second * 4,
+	}
+	cfg.Nodes["verifier3"] = &rollupNode.Config{
+		Driver: driver.Config{
+			VerifierConfDepth:  0,
+			SequencerConfDepth: 0,
+			SequencerEnabled:   false,
+		},
+		L1EpochPollInterval: time.Second * 4,
+	}
+	cfg.Loggers["verifier2"] = testlog.Logger(t, log.LvlInfo).New("role", "verifier")
+	cfg.Loggers["verifier3"] = testlog.Logger(t, log.LvlInfo).New("role", "verifier")
+
+	// Construct a new sequencer with an invalid privkey to produce invalid gossip
+	// We can then test that the peer scoring system will ban the node
+	sequencer2PrivateKey := cfg.Secrets.Mallory
+	cfg.Nodes["sequencer2"] = &rollupNode.Config{
+		Driver: driver.Config{
+			VerifierConfDepth:  0,
+			SequencerConfDepth: 0,
+			SequencerEnabled:   true,
+		},
+		// Submitter PrivKey is set in system start for rollup nodes where sequencer = true
+		RPC: rollupNode.RPCConfig{
+			ListenAddr:  "127.0.0.1",
+			ListenPort:  0,
+			EnableAdmin: true,
+		},
+		L1EpochPollInterval: time.Second * 4,
+		P2PSigner:           &p2p.PreparedSigner{Signer: p2p.NewLocalSigner(sequencer2PrivateKey)},
+	}
+	cfg.Loggers["sequencer2"] = testlog.Logger(t, log.LvlInfo).New("role", "sequencer")
+
+	// connect the nodes
+	cfg.P2PTopology = map[string][]string{
+		"verifier":  {"sequencer", "sequencer2", "verifier2", "verifier3"},
+		"verifier2": {"sequencer", "sequencer2", "verifier", "verifier3"},
+		"verifier3": {"sequencer", "sequencer2", "verifier", "verifier2"},
+	}
+
+	// Set peer scoring for each node, but without banning
+	for _, node := range cfg.Nodes {
+		params, err := p2p.GetPeerScoreParams("light", 2)
+		require.NoError(t, err)
+		node.P2P = &p2p.Config{
+			PeerScoring:    params,
+			BanningEnabled: false,
+		}
+	}
+
+	var published, published2, received1, received2, received3 []common.Hash
+	seqTracer, verifTracer, verifTracer2, verifTracer3 := new(FnTracer), new(FnTracer), new(FnTracer), new(FnTracer)
+	seq2Tracer := new(FnTracer)
+	seqTracer.OnPublishL2PayloadFn = func(ctx context.Context, payload *eth.ExecutionPayload) {
+		published = append(published, payload.BlockHash)
+	}
+	seq2Tracer.OnPublishL2PayloadFn = func(ctx context.Context, payload *eth.ExecutionPayload) {
+		published2 = append(published2, payload.BlockHash)
+	}
+	verifTracer.OnUnsafeL2PayloadFn = func(ctx context.Context, from peer.ID, payload *eth.ExecutionPayload) {
+		received1 = append(received1, payload.BlockHash)
+	}
+	verifTracer2.OnUnsafeL2PayloadFn = func(ctx context.Context, from peer.ID, payload *eth.ExecutionPayload) {
+		received2 = append(received2, payload.BlockHash)
+	}
+	verifTracer3.OnUnsafeL2PayloadFn = func(ctx context.Context, from peer.ID, payload *eth.ExecutionPayload) {
+		received3 = append(received3, payload.BlockHash)
+	}
+	cfg.Nodes["sequencer"].Tracer = seqTracer
+	cfg.Nodes["sequencer2"].Tracer = seq2Tracer
+	cfg.Nodes["verifier"].Tracer = verifTracer
+	cfg.Nodes["verifier2"].Tracer = verifTracer2
+	cfg.Nodes["verifier3"].Tracer = verifTracer3
+
+	sys, err := cfg.Start()
+	require.Nil(t, err, "Error starting up system")
+	defer sys.Close()
+
+	l2Seq := sys.Clients["sequencer"]
+	// l2Seq2 := sys.Clients["sequencer2"]
+	l2Verif := sys.Clients["verifier"]
+	l2Verif2 := sys.Clients["verifier2"]
+	l2Verif3 := sys.Clients["verifier3"]
+
+	// Transactor Account
+	ethPrivKey := cfg.Secrets.Alice
+
+	// Submit TX to L2 sequencer node
+	toAddr := common.Address{0xff, 0xff}
+	tx := types.MustSignNewTx(ethPrivKey, types.LatestSignerForChainID(cfg.L2ChainIDBig()), &types.DynamicFeeTx{
+		ChainID:   cfg.L2ChainIDBig(),
+		Nonce:     0,
+		To:        &toAddr,
+		Value:     big.NewInt(1_000_000_000),
+		GasTipCap: big.NewInt(10),
+		GasFeeCap: big.NewInt(200),
+		Gas:       21000,
+	})
+	err = l2Seq.SendTransaction(context.Background(), tx)
+	require.Nil(t, err, "Sending L2 tx to sequencer")
+
+	// Wait for tx to be mined on the L2 sequencer chain
+	receiptSeq, err := waitForTransaction(tx.Hash(), l2Seq, 6*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	require.Nil(t, err, "Waiting for L2 tx on sequencer")
+
+	// Wait until the block it was first included in shows up in the safe chain on the verifier
+	receiptVerif, err := waitForTransaction(tx.Hash(), l2Verif, 6*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	require.Nil(t, err, "Waiting for L2 tx on verifier")
+	require.Equal(t, receiptSeq, receiptVerif)
+
+	receiptVerif, err = waitForTransaction(tx.Hash(), l2Verif2, 6*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	require.Nil(t, err, "Waiting for L2 tx on verifier2")
+	require.Equal(t, receiptSeq, receiptVerif)
+
+	receiptVerif, err = waitForTransaction(tx.Hash(), l2Verif3, 6*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	require.Nil(t, err, "Waiting for L2 tx on verifier3")
+	require.Equal(t, receiptSeq, receiptVerif)
+
+	// Verify that everything that was received was published
+	require.GreaterOrEqual(t, len(published), len(received1))
+	require.GreaterOrEqual(t, len(published), len(received2))
+	require.GreaterOrEqual(t, len(published), len(received3))
+	require.ElementsMatch(t, published, received1[:len(published)])
+	require.ElementsMatch(t, published, received2[:len(published)])
+	require.ElementsMatch(t, published, received3[:len(published)])
+
+	// Verify that the tx was received via p2p
+	require.Contains(t, received1, receiptVerif.BlockHash)
+	require.Contains(t, received2, receiptVerif.BlockHash)
+	require.Contains(t, received3, receiptVerif.BlockHash)
+
+	// Submit TX to the second (malicious) sequencer node
+	// toAddr = common.Address{0xff, 0xff}
+	// maliciousTx := types.MustSignNewTx(ethPrivKey, types.LatestSignerForChainID(cfg.L2ChainIDBig()), &types.DynamicFeeTx{
+	// 	ChainID:   cfg.L2ChainIDBig(),
+	// 	Nonce:     1,
+	// 	To:        &toAddr,
+	// 	Value:     big.NewInt(1_000_000_000),
+	// 	GasTipCap: big.NewInt(10),
+	// 	GasFeeCap: big.NewInt(200),
+	// 	Gas:       21000,
+	// })
+	// err = l2Seq2.SendTransaction(context.Background(), maliciousTx)
+	// require.Nil(t, err, "Sending L2 tx to sequencer")
+
+	// Wait for tx to be mined on the L2 sequencer chain
+	// receiptSeq, err = waitForTransaction(maliciousTx.Hash(), l2Seq2, 6*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	// require.Nil(t, err, "Waiting for L2 tx on sequencer")
+
+	// Wait until the block it was first included in shows up in the safe chain on the verifier
+	// receiptVerif, err = waitForTransaction(maliciousTx.Hash(), l2Verif, 6*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	// require.Nil(t, err, "Waiting for L2 tx on verifier")
+	// require.Equal(t, receiptSeq, receiptVerif)
+
+	// receiptVerif, err = waitForTransaction(tx.Hash(), l2Verif2, 6*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	// require.Nil(t, err, "Waiting for L2 tx on verifier2")
+	// require.Equal(t, receiptSeq, receiptVerif)
+
+	// receiptVerif, err = waitForTransaction(tx.Hash(), l2Verif3, 6*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	// require.Nil(t, err, "Waiting for L2 tx on verifier3")
+	// require.Equal(t, receiptSeq, receiptVerif)
+}
+
 func TestL1InfoContract(t *testing.T) {
 	parallel(t)
 	if !verboseGethNodes {

op-node/cmd/batch_decoder/README.md

+# Batch Decoding Tool
+
+The batch decoding tool is a utility to aid in debugging the batch submitter & the op-node
+by looking at what batches were submitted on L1.
+
+## Design Philosophy
+
+The `batch_decoder` tool is designed to be simple & flexible. It offloads as much data analysis
+as possible to other tools. It is built around manipulating JSON on disk. The first stage is to
+fetch all transaction which are sent to a batch inbox address. Those transactions are decoded into
+frames in that step & information about them is recorded. After transactions are fetched the frames
+are re-assembled into channels in a second step that does not touch the network.
+
+
+## Commands
+
+### Fetch
+
+`batch_decoder fetch` pulls all L1 transactions sent to the batch inbox address in a given L1 block
+range and then stores them on disk to a specified path as JSON files where the name of the file is
+the transaction hash.
+
+### Reassemble
+
+`batch_decoder reassemble` goes through all of the found frames in the cache & then turns them
+into channels. It then stores the channels with metadata on disk where the file name is the Channel ID.
+
+
+## JQ Cheat Sheet
+
+`jq` is a really useful utility for manipulating JSON files.
+
+```
+# Pretty print a JSON file
+jq . $JSON_FILE
+
+# Print the number of valid & invalid transactions
+jq .valid_data $TX_DIR/* | sort | uniq -c  
+
+# Select all transactions that have invalid data & then print the transaction hash
+jq "select(.valid_data == false)|.tx.hash" $TX_DIR
+
+# Select all channels that are not ready and then get the id and inclusion block & tx hash of the first frame.
+jq "select(.is_ready == false)|[.id, .frames[0].inclusion_block, .frames[0].transaction_hash]"  $CHANNEL_DIR
+```
+
+
+## Roadmap
+
+- Parallel transaction fetching (CLI-3563)
+- Create force-close channel tx data from channel ID (CLI-3564)
+- Pull the batches out of channels & store that information inside the ChannelWithMetadata (CLI-3565)
+	- Transaction Bytes used
+	- Total uncompressed (different from tx bytes) + compressed bytes
+- Invert ChannelWithMetadata so block numbers/hashes are mapped to channels they are submitted in (CLI-3560)

op-node/cmd/batch_decoder/fetch/fetch.go

@@ -16,11 +16,12 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
-type TransactionWithMeta struct {
+type TransactionWithMetadata struct {
 	TxIndex     uint64             `json:"tx_index"`
 	InboxAddr   common.Address     `json:"inbox_address"`
 	BlockNumber uint64             `json:"block_number"`
 	BlockHash   common.Hash        `json:"block_hash"`
+	BlockTime   uint64             `json:"block_time"`
 	ChainId     uint64             `json:"chain_id"`
 	Sender      common.Address     `json:"sender"`
 	ValidSender bool               `json:"valid_sender"`
@@ -38,6 +39,9 @@ type Config struct {
 	OutDirectory string
 }
 
+// Batches fetches & stores all transactions sent to the batch inbox address in
+// the given block range (inclusive to exclusive).
+// The transactions & metadata are written to the out directory.
 func Batches(client *ethclient.Client, config Config) (totalValid, totalInvalid int) {
 	if err := os.MkdirAll(config.OutDirectory, 0750); err != nil {
 		log.Fatal(err)
@@ -53,13 +57,15 @@ func Batches(client *ethclient.Client, config Config) (totalValid, totalInvalid
 	return
 }
 
+// fetchBatchesPerBlock gets a block & the parses all of the transactions in the block.
 func fetchBatchesPerBlock(client *ethclient.Client, number *big.Int, signer types.Signer, config Config) (validBatchCount, invalidBatchCount int) {
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 	defer cancel()
 	block, err := client.BlockByNumber(ctx, number)
 	if err != nil {
 		log.Fatal(err)
 	}
+	fmt.Println("Fetched block: ", number)
 	for i, tx := range block.Transactions() {
 		if tx.To() != nil && *tx.To() == config.BatchInbox {
 			sender, err := signer.Sender(tx)
@@ -88,13 +94,14 @@ func fetchBatchesPerBlock(client *ethclient.Client, number *big.Int, signer type
 				invalidBatchCount += 1
 			}
 
-			txm := &TransactionWithMeta{
+			txm := &TransactionWithMetadata{
 				Tx:          tx,
 				Sender:      sender,
 				ValidSender: validSender,
 				TxIndex:     uint64(i),
 				BlockNumber: block.NumberU64(),
 				BlockHash:   block.Hash(),
+				BlockTime:   block.Time(),
 				ChainId:     config.ChainID.Uint64(),
 				InboxAddr:   config.BatchInbox,
 				Frames:      frames,

op-node/cmd/batch_decoder/main.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-node/cmd/batch_decoder/fetch"
+	"github.com/ethereum-optimism/optimism/op-node/cmd/batch_decoder/reassemble"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/urfave/cli"
@@ -59,7 +60,7 @@ func main() {
 				if err != nil {
 					log.Fatal(err)
 				}
-				ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+				ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 				defer cancel()
 				chainID, err := client.ChainID(ctx)
 				if err != nil {
@@ -82,6 +83,36 @@ func main() {
 				return nil
 			},
 		},
+		{
+			Name:  "reassemble",
+			Usage: "Reassembles channels from fetched batches",
+			Flags: []cli.Flag{
+				cli.StringFlag{
+					Name:  "inbox",
+					Value: "0xff00000000000000000000000000000000000420",
+					Usage: "Batch Inbox Address",
+				},
+				cli.StringFlag{
+					Name:  "in",
+					Value: "/tmp/batch_decoder/transactions_cache",
+					Usage: "Cache directory for the found transactions",
+				},
+				cli.StringFlag{
+					Name:  "out",
+					Value: "/tmp/batch_decoder/channel_cache",
+					Usage: "Cache directory for the found channels",
+				},
+			},
+			Action: func(cliCtx *cli.Context) error {
+				config := reassemble.Config{
+					BatchInbox:   common.HexToAddress(cliCtx.String("inbox")),
+					InDirectory:  cliCtx.String("in"),
+					OutDirectory: cliCtx.String("out"),
+				}
+				reassemble.Channels(config)
+				return nil
+			},
+		},
 	}
 
 	if err := app.Run(os.Args); err != nil {

op-node/cmd/batch_decoder/reassemble/reassemble.go

+package reassemble
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path"
+	"sort"
+
+	"github.com/ethereum-optimism/optimism/op-node/cmd/batch_decoder/fetch"
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type ChannelWithMetadata struct {
+	ID             derive.ChannelID    `json:"id"`
+	IsReady        bool                `json:"is_ready"`
+	InvalidFrames  bool                `json:"invalid_frames"`
+	InvalidBatches bool                `json:"invalid_batches"`
+	Frames         []FrameWithMetadata `json:"frames"`
+	Batches        []derive.BatchV1    `json:"batches"`
+}
+
+type FrameWithMetadata struct {
+	TxHash         common.Hash  `json:"transaction_hash"`
+	InclusionBlock uint64       `json:"inclusion_block"`
+	Timestamp      uint64       `json:"timestamp"`
+	BlockHash      common.Hash  `json:"block_hash"`
+	Frame          derive.Frame `json:"frame"`
+}
+
+type Config struct {
+	BatchInbox   common.Address
+	InDirectory  string
+	OutDirectory string
+}
+
+// Channels loads all transactions from the given input directory that are submitted to the
+// specified batch inbox and then re-assembles all channels & writes the re-assembled channels
+// to the out directory.
+func Channels(config Config) {
+	if err := os.MkdirAll(config.OutDirectory, 0750); err != nil {
+		log.Fatal(err)
+	}
+	txns := loadTransactions(config.InDirectory, config.BatchInbox)
+	// Sort first by block number then by transaction index inside the block number range.
+	// This is to match the order they are processed in derivation.
+	sort.Slice(txns, func(i, j int) bool {
+		if txns[i].BlockNumber == txns[j].BlockNumber {
+			return txns[i].TxIndex < txns[j].TxIndex
+		} else {
+			return txns[i].BlockNumber < txns[j].BlockNumber
+		}
+
+	})
+	frames := transactionsToFrames(txns)
+	framesByChannel := make(map[derive.ChannelID][]FrameWithMetadata)
+	for _, frame := range frames {
+		framesByChannel[frame.Frame.ID] = append(framesByChannel[frame.Frame.ID], frame)
+	}
+	for id, frames := range framesByChannel {
+		ch := processFrames(id, frames)
+		filename := path.Join(config.OutDirectory, fmt.Sprintf("%s.json", id.String()))
+		if err := writeChannel(ch, filename); err != nil {
+			log.Fatal(err)
+		}
+	}
+}
+
+func writeChannel(ch ChannelWithMetadata, filename string) error {
+	file, err := os.Create(filename)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer file.Close()
+	enc := json.NewEncoder(file)
+	return enc.Encode(ch)
+}
+
+func processFrames(id derive.ChannelID, frames []FrameWithMetadata) ChannelWithMetadata {
+	ch := derive.NewChannel(id, eth.L1BlockRef{Number: frames[0].InclusionBlock})
+	invalidFrame := false
+
+	for _, frame := range frames {
+		if ch.IsReady() {
+			fmt.Printf("Channel %v is ready despite having more frames\n", id.String())
+			invalidFrame = true
+			break
+		}
+		if err := ch.AddFrame(frame.Frame, eth.L1BlockRef{Number: frame.InclusionBlock}); err != nil {
+			fmt.Printf("Error adding to channel %v. Err: %v\n", id.String(), err)
+			invalidFrame = true
+		}
+	}
+
+	var batches []derive.BatchV1
+	invalidBatches := false
+	if ch.IsReady() {
+		br, err := derive.BatchReader(ch.Reader(), eth.L1BlockRef{})
+		if err == nil {
+			for batch, err := br(); err != io.EOF; batch, err = br() {
+				if err != nil {
+					fmt.Printf("Error reading batch for channel %v. Err: %v\n", id.String(), err)
+					invalidBatches = true
+				} else {
+					batches = append(batches, batch.Batch.BatchV1)
+				}
+			}
+		} else {
+			fmt.Printf("Error creating batch reader for channel %v. Err: %v\n", id.String(), err)
+		}
+	} else {
+		fmt.Printf("Channel %v is not ready\n", id.String())
+	}
+
+	return ChannelWithMetadata{
+		ID:             id,
+		Frames:         frames,
+		IsReady:        ch.IsReady(),
+		InvalidFrames:  invalidFrame,
+		InvalidBatches: invalidBatches,
+		Batches:        batches,
+	}
+}
+
+func transactionsToFrames(txns []fetch.TransactionWithMetadata) []FrameWithMetadata {
+	var out []FrameWithMetadata
+	for _, tx := range txns {
+		for _, frame := range tx.Frames {
+			fm := FrameWithMetadata{
+				TxHash:         tx.Tx.Hash(),
+				InclusionBlock: tx.BlockNumber,
+				BlockHash:      tx.BlockHash,
+				Timestamp:      tx.BlockTime,
+				Frame:          frame,
+			}
+			out = append(out, fm)
+		}
+	}
+	return out
+}
+
+func loadTransactions(dir string, inbox common.Address) []fetch.TransactionWithMetadata {
+	files, err := os.ReadDir(dir)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var out []fetch.TransactionWithMetadata
+	for _, file := range files {
+		f := path.Join(dir, file.Name())
+		txm := loadTransactionsFile(f)
+		if txm.InboxAddr == inbox && txm.ValidSender {
+			out = append(out, txm)
+		}
+	}
+	return out
+}
+
+func loadTransactionsFile(file string) fetch.TransactionWithMetadata {
+	f, err := os.Open(file)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+	dec := json.NewDecoder(f)
+	var txm fetch.TransactionWithMetadata
+	if err := dec.Decode(&txm); err != nil {
+		log.Fatalf("Failed to decode %v. Err: %v\n", file, err)
+	}
+	return txm
+}

op-node/flags/p2p_flags.go

@@ -25,6 +25,33 @@ var (
 		Required: false,
 		EnvVar:   p2pEnv("NO_DISCOVERY"),
 	}
+	PeerScoring = cli.StringFlag{
+		Name: "p2p.scoring.peers",
+		Usage: "Sets the peer scoring strategy for the P2P stack. " +
+			"Can be one of: none or light." +
+			"Custom scoring strategies can be defined in the config file.",
+		Required: false,
+		Value:    "none",
+		EnvVar:   p2pEnv("PEER_SCORING"),
+	}
+
+	// Banning Flag - whether or not we want to act on the scoring
+	Banning = cli.BoolFlag{
+		Name:     "p2p.ban.peers",
+		Usage:    "Enables peer banning. This should ONLY be enabled once certain peer scoring is working correctly.",
+		Required: false,
+		EnvVar:   p2pEnv("PEER_BANNING"),
+	}
+
+	TopicScoring = cli.StringFlag{
+		Name: "p2p.scoring.topics",
+		Usage: "Sets the topic scoring strategy. " +
+			"Can be one of: none or light." +
+			"Custom scoring strategies can be defined in the config file.",
+		Required: false,
+		Value:    "none",
+		EnvVar:   p2pEnv("TOPIC_SCORING"),
+	}
 	P2PPrivPath = cli.StringFlag{
 		Name: "p2p.priv.path",
 		Usage: "Read the hex-encoded 32-byte private key for the peer ID from this txt file. Created if not already exists." +

op-node/metrics/metrics.go

@@ -15,6 +15,7 @@ import (
 
 	pb "github.com/libp2p/go-libp2p-pubsub/pb"
 	libp2pmetrics "github.com/libp2p/go-libp2p/core/metrics"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/collectors"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
@@ -64,6 +65,8 @@ type Metricer interface {
 	RecordSequencerBuildingDiffTime(duration time.Duration)
 	RecordSequencerSealingTime(duration time.Duration)
 	Document() []metrics.DocumentedMetric
+	// P2P Metrics
+	RecordPeerScoring(peerID peer.ID, score float64)
 }
 
 // Metrics tracks all the metrics for the op-node.
@@ -116,6 +119,7 @@ type Metrics struct {
 	// P2P Metrics
 	PeerCount         prometheus.Gauge
 	StreamCount       prometheus.Gauge
+	PeerScores        *prometheus.GaugeVec
 	GossipEventsTotal *prometheus.CounterVec
 	BandwidthTotal    *prometheus.GaugeVec
 
@@ -289,6 +293,16 @@ func NewMetrics(procName string) *Metrics {
 			Name:      "stream_count",
 			Help:      "Count of currently connected p2p streams",
 		}),
+		PeerScores: factory.NewGaugeVec(prometheus.GaugeOpts{
+			Namespace: ns,
+			Subsystem: "p2p",
+			Name:      "peer_scores",
+			Help:      "Peer scoring",
+		}, []string{
+			// No label names here since peer ids would open a service attack vector.
+			// Each peer id would be a separate metric, flooding prometheus.
+			// See: https://prometheus.io/docs/practices/naming/#labels
+		}),
 		GossipEventsTotal: factory.NewCounterVec(prometheus.CounterOpts{
 			Namespace: ns,
 			Subsystem: "p2p",
@@ -477,6 +491,10 @@ func (m *Metrics) RecordGossipEvent(evType int32) {
 	m.GossipEventsTotal.WithLabelValues(pb.TraceEvent_Type_name[evType]).Inc()
 }
 
+func (m *Metrics) RecordPeerScoring(peerID peer.ID, score float64) {
+	m.PeerScores.WithLabelValues(peerID.String()).Set(score)
+}
+
 func (m *Metrics) IncPeerCount() {
 	m.PeerCount.Inc()
 }
@@ -609,6 +627,9 @@ func (n *noopMetricer) RecordSequencerReset() {
 func (n *noopMetricer) RecordGossipEvent(evType int32) {
 }
 
+func (n *noopMetricer) RecordPeerScoring(peerID peer.ID, score float64) {
+}
+
 func (n *noopMetricer) IncPeerCount() {
 }
 

op-node/p2p/cli/load_config.go

@@ -24,7 +24,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/enode"
 )
 
-func NewConfig(ctx *cli.Context) (*p2p.Config, error) {
+func NewConfig(ctx *cli.Context, blockTime uint64) (*p2p.Config, error) {
 	conf := &p2p.Config{}
 
 	if ctx.GlobalBool(flags.DisableP2P.Name) {
@@ -54,6 +54,18 @@ func NewConfig(ctx *cli.Context) (*p2p.Config, error) {
 		return nil, fmt.Errorf("failed to load p2p gossip options: %w", err)
 	}
 
+	if err := loadPeerScoringParams(conf, ctx, blockTime); err != nil {
+		return nil, fmt.Errorf("failed to load p2p peer scoring options: %w", err)
+	}
+
+	if err := loadBanningOption(conf, ctx); err != nil {
+		return nil, fmt.Errorf("failed to load banning option: %w", err)
+	}
+
+	if err := loadTopicScoringParams(conf, ctx, blockTime); err != nil {
+		return nil, fmt.Errorf("failed to load p2p topic scoring options: %w", err)
+	}
+
 	conf.ConnGater = p2p.DefaultConnGater
 	conf.ConnMngr = p2p.DefaultConnManager
 
@@ -73,6 +85,49 @@ func validatePort(p uint) (uint16, error) {
 	return uint16(p), nil
 }
 
+// loadTopicScoringParams loads the topic scoring options from the CLI context.
+//
+// If the topic scoring options are not set, then the default topic scoring.
+func loadTopicScoringParams(conf *p2p.Config, ctx *cli.Context, blockTime uint64) error {
+	scoringLevel := ctx.GlobalString(flags.TopicScoring.Name)
+	if scoringLevel != "" {
+		// Set default block topic scoring parameters
+		// See prysm: https://github.com/prysmaticlabs/prysm/blob/develop/beacon-chain/p2p/gossip_scoring_params.go
+		// And research from lighthouse: https://gist.github.com/blacktemplar/5c1862cb3f0e32a1a7fb0b25e79e6e2c
+		// And docs: https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.1.md#topic-parameter-calculation-and-decay
+		topicScoreParams, err := p2p.GetTopicScoreParams(scoringLevel, blockTime)
+		if err != nil {
+			return err
+		}
+		conf.TopicScoring = topicScoreParams
+	}
+
+	return nil
+}
+
+// loadPeerScoringParams loads the scoring options from the CLI context.
+//
+// If the scoring level is not set, no scoring is enabled.
+func loadPeerScoringParams(conf *p2p.Config, ctx *cli.Context, blockTime uint64) error {
+	scoringLevel := ctx.GlobalString(flags.PeerScoring.Name)
+	if scoringLevel != "" {
+		peerScoreParams, err := p2p.GetPeerScoreParams(scoringLevel, blockTime)
+		if err != nil {
+			return err
+		}
+		conf.PeerScoring = peerScoreParams
+	}
+
+	return nil
+}
+
+// loadBanningOption loads whether or not to ban peers from the CLI context.
+func loadBanningOption(conf *p2p.Config, ctx *cli.Context) error {
+	ban := ctx.GlobalBool(flags.Banning.Name)
+	conf.BanningEnabled = ban
+	return nil
+}
+
 func loadListenOpts(conf *p2p.Config, ctx *cli.Context) error {
 	listenIP := ctx.GlobalString(flags.ListenIP.Name)
 	if listenIP != "" { // optional

op-node/p2p/config.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	ds "github.com/ipfs/go-datastore"
 	"github.com/libp2p/go-libp2p"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core"
 	"github.com/libp2p/go-libp2p/core/connmgr"
 	"github.com/libp2p/go-libp2p/core/crypto"
@@ -49,6 +50,13 @@ type Config struct {
 	DisableP2P  bool
 	NoDiscovery bool
 
+	// Pubsub Scoring Parameters
+	PeerScoring  pubsub.PeerScoreParams
+	TopicScoring pubsub.TopicScoreParams
+
+	// Whether to ban peers based on their [PeerScoring] score.
+	BanningEnabled bool
+
 	ListenIP      net.IP
 	ListenTCPPort uint16
 
@@ -95,6 +103,7 @@ type Config struct {
 	ConnMngr  func(conf *Config) (connmgr.ConnManager, error)
 }
 
+//go:generate mockery --name ConnectionGater
 type ConnectionGater interface {
 	connmgr.ConnectionGater
 
@@ -138,6 +147,18 @@ func (conf *Config) Disabled() bool {
 	return conf.DisableP2P
 }
 
+func (conf *Config) PeerScoringParams() *pubsub.PeerScoreParams {
+	return &conf.PeerScoring
+}
+
+func (conf *Config) BanPeers() bool {
+	return conf.BanningEnabled
+}
+
+func (conf *Config) TopicScoringParams() *pubsub.TopicScoreParams {
+	return &conf.TopicScoring
+}
+
 const maxMeshParam = 1000
 
 func (conf *Config) Check() error {

op-node/p2p/gossip.go

@@ -40,6 +40,8 @@ const (
 	DefaultMeshDlo   = 6  // topic stable mesh low watermark
 	DefaultMeshDhi   = 12 // topic stable mesh high watermark
 	DefaultMeshDlazy = 6  // gossip target
+	// peerScoreInspectFrequency is the frequency at which peer scores are inspected
+	peerScoreInspectFrequency = 15 * time.Second
 )
 
 // Message domains, the msg id function uncompresses to keep data monomorphic,
@@ -49,6 +51,9 @@ var MessageDomainInvalidSnappy = [4]byte{0, 0, 0, 0}
 var MessageDomainValidSnappy = [4]byte{1, 0, 0, 0}
 
 type GossipSetupConfigurables interface {
+	PeerScoringParams() *pubsub.PeerScoreParams
+	TopicScoringParams() *pubsub.TopicScoreParams
+	BanPeers() bool
 	ConfigureGossip(params *pubsub.GossipSubParams) []pubsub.Option
 }
 
@@ -56,8 +61,10 @@ type GossipRuntimeConfig interface {
 	P2PSequencerAddress() common.Address
 }
 
+//go:generate mockery --name GossipMetricer
 type GossipMetricer interface {
 	RecordGossipEvent(evType int32)
+	RecordPeerScoring(peerID peer.ID, score float64)
 }
 
 func blocksTopicV1(cfg *rollup.Config) string {
@@ -143,7 +150,7 @@ func BuildGlobalGossipParams(cfg *rollup.Config) pubsub.GossipSubParams {
 
 // NewGossipSub configures a new pubsub instance with the specified parameters.
 // PubSub uses a GossipSubRouter as it's router under the hood.
-func NewGossipSub(p2pCtx context.Context, h host.Host, cfg *rollup.Config, gossipConf GossipSetupConfigurables, m GossipMetricer) (*pubsub.PubSub, error) {
+func NewGossipSub(p2pCtx context.Context, h host.Host, g ConnectionGater, cfg *rollup.Config, gossipConf GossipSetupConfigurables, m GossipMetricer, log log.Logger) (*pubsub.PubSub, error) {
 	denyList, err := pubsub.NewTimeCachedBlacklist(30 * time.Second)
 	if err != nil {
 		return nil, err
@@ -164,9 +171,9 @@ func NewGossipSub(p2pCtx context.Context, h host.Host, cfg *rollup.Config, gossi
 		pubsub.WithGossipSubParams(params),
 		pubsub.WithEventTracer(&gossipTracer{m: m}),
 	}
+	gossipOpts = append(gossipOpts, ConfigurePeerScoring(h, g, gossipConf, m, log)...)
 	gossipOpts = append(gossipOpts, gossipConf.ConfigureGossip(&params)...)
 	return pubsub.NewGossipSub(p2pCtx, h, gossipOpts...)
-	// TODO: pubsub.WithPeerScoreInspect(inspect, InspectInterval) to update peerstore scores with gossip scores
 }
 
 func validationResultString(v pubsub.ValidationResult) string {
@@ -431,7 +438,7 @@ func (p *publisher) Close() error {
 	return p.blocksTopic.Close()
 }
 
-func JoinGossip(p2pCtx context.Context, self peer.ID, ps *pubsub.PubSub, log log.Logger, cfg *rollup.Config, runCfg GossipRuntimeConfig, gossipIn GossipIn) (GossipOut, error) {
+func JoinGossip(p2pCtx context.Context, self peer.ID, topicScoreParams *pubsub.TopicScoreParams, ps *pubsub.PubSub, log log.Logger, cfg *rollup.Config, runCfg GossipRuntimeConfig, gossipIn GossipIn) (GossipOut, error) {
 	val := guardGossipValidator(log, logValidationResult(self, "validated block", log, BuildBlocksValidator(log, cfg, runCfg)))
 	blocksTopicName := blocksTopicV1(cfg)
 	err := ps.RegisterTopicValidator(blocksTopicName,
@@ -451,11 +458,14 @@ func JoinGossip(p2pCtx context.Context, self peer.ID, ps *pubsub.PubSub, log log
 	}
 	go LogTopicEvents(p2pCtx, log.New("topic", "blocks"), blocksTopicEvents)
 
-	// TODO: block topic scoring parameters
-	// See prysm: https://github.com/prysmaticlabs/prysm/blob/develop/beacon-chain/p2p/gossip_scoring_params.go
-	// And research from lighthouse: https://gist.github.com/blacktemplar/5c1862cb3f0e32a1a7fb0b25e79e6e2c
-	// And docs: https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.1.md#topic-parameter-calculation-and-decay
-	//err := blocksTopic.SetScoreParams(&pubsub.TopicScoreParams{......})
+	// A [TimeInMeshQuantum] value of 0 means the topic score is disabled.
+	// If we passed a topicScoreParams with [TimeInMeshQuantum] set to 0,
+	// libp2p errors since the params will be rejected.
+	if topicScoreParams != nil && topicScoreParams.TimeInMeshQuantum != 0 {
+		if err = blocksTopic.SetScoreParams(topicScoreParams); err != nil {
+			return nil, fmt.Errorf("failed to set topic score params: %w", err)
+		}
+	}
 
 	subscription, err := blocksTopic.Subscribe()
 	if err != nil {

op-node/p2p/host_test.go

@@ -168,7 +168,7 @@ func TestP2PFull(t *testing.T) {
 
 	_, err = p2pClientA.DiscoveryTable(ctx)
 	// rpc does not preserve error type
-	require.Equal(t, err.Error(), DisabledDiscovery.Error(), "expecting discv5 to be disabled")
+	require.Equal(t, err.Error(), ErrDisabledDiscovery.Error(), "expecting discv5 to be disabled")
 
 	require.NoError(t, p2pClientA.BlockPeer(ctx, hostB.ID()))
 	blockedPeers, err := p2pClientA.ListBlockedPeers(ctx)

op-node/p2p/mocks/ConnectionGater.go

+// Code generated by mockery v2.14.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	control "github.com/libp2p/go-libp2p/core/control"
+	mock "github.com/stretchr/testify/mock"
+
+	multiaddr "github.com/multiformats/go-multiaddr"
+
+	net "net"
+
+	network "github.com/libp2p/go-libp2p/core/network"
+
+	peer "github.com/libp2p/go-libp2p/core/peer"
+)
+
+// ConnectionGater is an autogenerated mock type for the ConnectionGater type
+type ConnectionGater struct {
+	mock.Mock
+}
+
+// BlockAddr provides a mock function with given fields: ip
+func (_m *ConnectionGater) BlockAddr(ip net.IP) error {
+	ret := _m.Called(ip)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(net.IP) error); ok {
+		r0 = rf(ip)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// BlockPeer provides a mock function with given fields: p
+func (_m *ConnectionGater) BlockPeer(p peer.ID) error {
+	ret := _m.Called(p)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(peer.ID) error); ok {
+		r0 = rf(p)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// BlockSubnet provides a mock function with given fields: ipnet
+func (_m *ConnectionGater) BlockSubnet(ipnet *net.IPNet) error {
+	ret := _m.Called(ipnet)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*net.IPNet) error); ok {
+		r0 = rf(ipnet)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// InterceptAccept provides a mock function with given fields: _a0
+func (_m *ConnectionGater) InterceptAccept(_a0 network.ConnMultiaddrs) bool {
+	ret := _m.Called(_a0)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(network.ConnMultiaddrs) bool); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// InterceptAddrDial provides a mock function with given fields: _a0, _a1
+func (_m *ConnectionGater) InterceptAddrDial(_a0 peer.ID, _a1 multiaddr.Multiaddr) bool {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(peer.ID, multiaddr.Multiaddr) bool); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// InterceptPeerDial provides a mock function with given fields: p
+func (_m *ConnectionGater) InterceptPeerDial(p peer.ID) bool {
+	ret := _m.Called(p)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(peer.ID) bool); ok {
+		r0 = rf(p)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// InterceptSecured provides a mock function with given fields: _a0, _a1, _a2
+func (_m *ConnectionGater) InterceptSecured(_a0 network.Direction, _a1 peer.ID, _a2 network.ConnMultiaddrs) bool {
+	ret := _m.Called(_a0, _a1, _a2)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(network.Direction, peer.ID, network.ConnMultiaddrs) bool); ok {
+		r0 = rf(_a0, _a1, _a2)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// InterceptUpgraded provides a mock function with given fields: _a0
+func (_m *ConnectionGater) InterceptUpgraded(_a0 network.Conn) (bool, control.DisconnectReason) {
+	ret := _m.Called(_a0)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(network.Conn) bool); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 control.DisconnectReason
+	if rf, ok := ret.Get(1).(func(network.Conn) control.DisconnectReason); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Get(1).(control.DisconnectReason)
+	}
+
+	return r0, r1
+}
+
+// ListBlockedAddrs provides a mock function with given fields:
+func (_m *ConnectionGater) ListBlockedAddrs() []net.IP {
+	ret := _m.Called()
+
+	var r0 []net.IP
+	if rf, ok := ret.Get(0).(func() []net.IP); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]net.IP)
+		}
+	}
+
+	return r0
+}
+
+// ListBlockedPeers provides a mock function with given fields:
+func (_m *ConnectionGater) ListBlockedPeers() []peer.ID {
+	ret := _m.Called()
+
+	var r0 []peer.ID
+	if rf, ok := ret.Get(0).(func() []peer.ID); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]peer.ID)
+		}
+	}
+
+	return r0
+}
+
+// ListBlockedSubnets provides a mock function with given fields:
+func (_m *ConnectionGater) ListBlockedSubnets() []*net.IPNet {
+	ret := _m.Called()
+
+	var r0 []*net.IPNet
+	if rf, ok := ret.Get(0).(func() []*net.IPNet); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*net.IPNet)
+		}
+	}
+
+	return r0
+}
+
+// UnblockAddr provides a mock function with given fields: ip
+func (_m *ConnectionGater) UnblockAddr(ip net.IP) error {
+	ret := _m.Called(ip)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(net.IP) error); ok {
+		r0 = rf(ip)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UnblockPeer provides a mock function with given fields: p
+func (_m *ConnectionGater) UnblockPeer(p peer.ID) error {
+	ret := _m.Called(p)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(peer.ID) error); ok {
+		r0 = rf(p)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UnblockSubnet provides a mock function with given fields: ipnet
+func (_m *ConnectionGater) UnblockSubnet(ipnet *net.IPNet) error {
+	ret := _m.Called(ipnet)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*net.IPNet) error); ok {
+		r0 = rf(ipnet)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+type mockConstructorTestingTNewConnectionGater interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewConnectionGater creates a new instance of ConnectionGater. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewConnectionGater(t mockConstructorTestingTNewConnectionGater) *ConnectionGater {
+	mock := &ConnectionGater{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

op-node/p2p/mocks/GossipMetricer.go

+// Code generated by mockery v2.14.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+
+	peer "github.com/libp2p/go-libp2p/core/peer"
+)
+
+// GossipMetricer is an autogenerated mock type for the GossipMetricer type
+type GossipMetricer struct {
+	mock.Mock
+}
+
+// RecordGossipEvent provides a mock function with given fields: evType
+func (_m *GossipMetricer) RecordGossipEvent(evType int32) {
+	_m.Called(evType)
+}
+
+// RecordPeerScoring provides a mock function with given fields: peerID, score
+func (_m *GossipMetricer) RecordPeerScoring(peerID peer.ID, score float64) {
+	_m.Called(peerID, score)
+}
+
+type mockConstructorTestingTNewGossipMetricer interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewGossipMetricer creates a new instance of GossipMetricer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewGossipMetricer(t mockConstructorTestingTNewGossipMetricer) *GossipMetricer {
+	mock := &GossipMetricer{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

op-node/p2p/mocks/PeerGater.go

+// Code generated by mockery v2.14.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+
+	peer "github.com/libp2p/go-libp2p/core/peer"
+)
+
+// PeerGater is an autogenerated mock type for the PeerGater type
+type PeerGater struct {
+	mock.Mock
+}
+
+// Update provides a mock function with given fields: _a0, _a1
+func (_m *PeerGater) Update(_a0 peer.ID, _a1 float64) {
+	_m.Called(_a0, _a1)
+}
+
+type mockConstructorTestingTNewPeerGater interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewPeerGater creates a new instance of PeerGater. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewPeerGater(t mockConstructorTestingTNewPeerGater) *PeerGater {
+	mock := &PeerGater{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

op-node/p2p/mocks/Peerstore.go

+// Code generated by mockery v2.14.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+
+	peer "github.com/libp2p/go-libp2p/core/peer"
+)
+
+// Peerstore is an autogenerated mock type for the Peerstore type
+type Peerstore struct {
+	mock.Mock
+}
+
+// PeerInfo provides a mock function with given fields: _a0
+func (_m *Peerstore) PeerInfo(_a0 peer.ID) peer.AddrInfo {
+	ret := _m.Called(_a0)
+
+	var r0 peer.AddrInfo
+	if rf, ok := ret.Get(0).(func(peer.ID) peer.AddrInfo); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Get(0).(peer.AddrInfo)
+	}
+
+	return r0
+}
+
+// Peers provides a mock function with given fields:
+func (_m *Peerstore) Peers() peer.IDSlice {
+	ret := _m.Called()
+
+	var r0 peer.IDSlice
+	if rf, ok := ret.Get(0).(func() peer.IDSlice); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(peer.IDSlice)
+		}
+	}
+
+	return r0
+}
+
+type mockConstructorTestingTNewPeerstore interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewPeerstore creates a new instance of Peerstore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewPeerstore(t mockConstructorTestingTNewPeerstore) *Peerstore {
+	mock := &Peerstore{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

op-node/p2p/node.go

@@ -76,12 +76,11 @@ func (n *NodeP2P) init(resourcesCtx context.Context, rollupCfg *rollup.Config, l
 		// notify of any new connections/streams/etc.
 		n.host.Network().Notify(NewNetworkNotifier(log, metrics))
 		// note: the IDDelta functionality was removed from libP2P, and no longer needs to be explicitly disabled.
-		n.gs, err = NewGossipSub(resourcesCtx, n.host, rollupCfg, setup, metrics)
+		n.gs, err = NewGossipSub(resourcesCtx, n.host, n.gater, rollupCfg, setup, metrics, log)
 		if err != nil {
 			return fmt.Errorf("failed to start gossipsub router: %w", err)
 		}
-
-		n.gsOut, err = JoinGossip(resourcesCtx, n.host.ID(), n.gs, log, rollupCfg, runCfg, gossipIn)
+		n.gsOut, err = JoinGossip(resourcesCtx, n.host.ID(), setup.TopicScoringParams(), n.gs, log, rollupCfg, runCfg, gossipIn)
 		if err != nil {
 			return fmt.Errorf("failed to join blocks gossip topic: %w", err)
 		}

op-node/p2p/peer_gater.go

+package p2p
+
+import (
+	log "github.com/ethereum/go-ethereum/log"
+	peer "github.com/libp2p/go-libp2p/core/peer"
+	slices "golang.org/x/exp/slices"
+)
+
+// ConnectionFactor is the factor by which we multiply the connection score.
+const ConnectionFactor = -10
+
+// PeerScoreThreshold is the threshold at which we block a peer.
+const PeerScoreThreshold = -100
+
+// gater is an internal implementation of the [PeerGater] interface.
+type gater struct {
+	connGater  ConnectionGater
+	log        log.Logger
+	banEnabled bool
+}
+
+// PeerGater manages the connection gating of peers.
+//
+//go:generate mockery --name PeerGater --output mocks/
+type PeerGater interface {
+	// Update handles a peer score update and blocks/unblocks the peer if necessary.
+	Update(peer.ID, float64)
+}
+
+// NewPeerGater returns a new peer gater.
+func NewPeerGater(connGater ConnectionGater, log log.Logger, banEnabled bool) PeerGater {
+	return &gater{
+		connGater:  connGater,
+		log:        log,
+		banEnabled: banEnabled,
+	}
+}
+
+// Update handles a peer score update and blocks/unblocks the peer if necessary.
+func (s *gater) Update(id peer.ID, score float64) {
+	// Check if the peer score is below the threshold
+	// If so, we need to block the peer
+	if score < PeerScoreThreshold && s.banEnabled {
+		s.log.Warn("peer blocking enabled, blocking peer", "id", id.String(), "score", score)
+		err := s.connGater.BlockPeer(id)
+		s.log.Warn("connection gater failed to block peer", id.String(), "err", err)
+	}
+	// Unblock peers whose score has recovered to an acceptable level
+	if (score > PeerScoreThreshold) && slices.Contains(s.connGater.ListBlockedPeers(), id) {
+		err := s.connGater.UnblockPeer(id)
+		s.log.Warn("connection gater failed to unblock peer", id.String(), "err", err)
+	}
+}

op-node/p2p/peer_gater_test.go

+package p2p_test
+
+import (
+	"testing"
+
+	p2p "github.com/ethereum-optimism/optimism/op-node/p2p"
+	p2pMocks "github.com/ethereum-optimism/optimism/op-node/p2p/mocks"
+	testlog "github.com/ethereum-optimism/optimism/op-node/testlog"
+	log "github.com/ethereum/go-ethereum/log"
+	peer "github.com/libp2p/go-libp2p/core/peer"
+	suite "github.com/stretchr/testify/suite"
+)
+
+// PeerGaterTestSuite tests peer parameterization.
+type PeerGaterTestSuite struct {
+	suite.Suite
+
+	mockGater *p2pMocks.ConnectionGater
+	logger    log.Logger
+}
+
+// SetupTest sets up the test suite.
+func (testSuite *PeerGaterTestSuite) SetupTest() {
+	testSuite.mockGater = &p2pMocks.ConnectionGater{}
+	testSuite.logger = testlog.Logger(testSuite.T(), log.LvlError)
+}
+
+// TestPeerGater runs the PeerGaterTestSuite.
+func TestPeerGater(t *testing.T) {
+	suite.Run(t, new(PeerGaterTestSuite))
+}
+
+// TestPeerScoreConstants validates the peer score constants.
+func (testSuite *PeerGaterTestSuite) TestPeerScoreConstants() {
+	testSuite.Equal(-10, p2p.ConnectionFactor)
+	testSuite.Equal(-100, p2p.PeerScoreThreshold)
+}
+
+// TestPeerGaterUpdate tests the peer gater update hook.
+func (testSuite *PeerGaterTestSuite) TestPeerGaterUpdate() {
+	gater := p2p.NewPeerGater(
+		testSuite.mockGater,
+		testSuite.logger,
+		true,
+	)
+
+	// Mock a connection gater peer block call
+	// Since the peer score is below the [PeerScoreThreshold] of -100,
+	// the [BlockPeer] method should be called
+	testSuite.mockGater.On("BlockPeer", peer.ID("peer1")).Return(nil)
+
+	// Apply the peer gater update
+	gater.Update(peer.ID("peer1"), float64(-100))
+}
+
+// TestPeerGaterUpdateNoBanning tests the peer gater update hook without banning set
+func (testSuite *PeerGaterTestSuite) TestPeerGaterUpdateNoBanning() {
+	gater := p2p.NewPeerGater(
+		testSuite.mockGater,
+		testSuite.logger,
+		false,
+	)
+
+	// Notice: [BlockPeer] should not be called since banning is not enabled
+	gater.Update(peer.ID("peer1"), float64(-100000))
+}

op-node/p2p/peer_params.go

+package p2p
+
+import (
+	"fmt"
+	"math"
+	"time"
+
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/libp2p/go-libp2p/core/peer"
+)
+
+// DecayToZero is the decay factor for a peer's score to zero.
+const DecayToZero = 0.01
+
+// ScoreDecay returns the decay factor for a given duration.
+func ScoreDecay(duration time.Duration, slot time.Duration) float64 {
+	numOfTimes := duration / slot
+	return math.Pow(DecayToZero, 1/float64(numOfTimes))
+}
+
+// LightPeerScoreParams is an instantiation of [pubsub.PeerScoreParams] with light penalties.
+// See [PeerScoreParams] for detailed documentation.
+//
+// [PeerScoreParams]: https://pkg.go.dev/github.com/libp2p/go-libp2p-pubsub@v0.8.1#PeerScoreParams
+var LightPeerScoreParams = func(blockTime uint64) pubsub.PeerScoreParams {
+	slot := time.Duration(blockTime) * time.Second
+	if slot == 0 {
+		slot = 2 * time.Second
+	}
+	// We initialize an "epoch" as 6 blocks suggesting 6 blocks,
+	// each taking ~ 2 seconds, is 12 seconds
+	epoch := 6 * slot
+	tenEpochs := 10 * epoch
+	oneHundredEpochs := 100 * epoch
+	return pubsub.PeerScoreParams{
+		Topics:        make(map[string]*pubsub.TopicScoreParams),
+		TopicScoreCap: 34,
+		AppSpecificScore: func(p peer.ID) float64 {
+			return 0
+		},
+		AppSpecificWeight:           1,
+		IPColocationFactorWeight:    -35,
+		IPColocationFactorThreshold: 10,
+		IPColocationFactorWhitelist: nil,
+		BehaviourPenaltyWeight:      -16,
+		BehaviourPenaltyThreshold:   6,
+		BehaviourPenaltyDecay:       ScoreDecay(tenEpochs, slot),
+		DecayInterval:               slot,
+		DecayToZero:                 DecayToZero,
+		RetainScore:                 oneHundredEpochs,
+	}
+}
+
+// DisabledPeerScoreParams is an instantiation of [pubsub.PeerScoreParams] where all scoring is disabled.
+// See [PeerScoreParams] for detailed documentation.
+//
+// [PeerScoreParams]: https://pkg.go.dev/github.com/libp2p/go-libp2p-pubsub@v0.8.1#PeerScoreParams
+var DisabledPeerScoreParams = func(blockTime uint64) pubsub.PeerScoreParams {
+	slot := time.Duration(blockTime) * time.Second
+	if slot == 0 {
+		slot = 2 * time.Second
+	}
+	// We initialize an "epoch" as 6 blocks suggesting 6 blocks,
+	// each taking ~ 2 seconds, is 12 seconds
+	epoch := 6 * slot
+	tenEpochs := 10 * epoch
+	oneHundredEpochs := 100 * epoch
+	return pubsub.PeerScoreParams{
+		Topics: make(map[string]*pubsub.TopicScoreParams),
+		// 0 represent no cap
+		TopicScoreCap: 0,
+		AppSpecificScore: func(p peer.ID) float64 {
+			return 0
+		},
+		AppSpecificWeight: 1,
+		// ignore colocation scoring
+		IPColocationFactorWeight:    0,
+		IPColocationFactorWhitelist: nil,
+		// 0 disables the behaviour penalty
+		BehaviourPenaltyWeight: 0,
+		BehaviourPenaltyDecay:  ScoreDecay(tenEpochs, slot),
+		DecayInterval:          slot,
+		DecayToZero:            DecayToZero,
+		RetainScore:            oneHundredEpochs,
+	}
+}
+
+// PeerScoreParamsByName is a map of name to function that returns a [pubsub.PeerScoreParams] based on the provided [rollup.Config].
+var PeerScoreParamsByName = map[string](func(blockTime uint64) pubsub.PeerScoreParams){
+	"light": LightPeerScoreParams,
+	"none":  DisabledPeerScoreParams,
+}
+
+// AvailablePeerScoreParams returns a list of available peer score params.
+// These can be used as an input to [GetPeerScoreParams] which returns the
+// corresponding [pubsub.PeerScoreParams].
+func AvailablePeerScoreParams() []string {
+	var params []string
+	for name := range PeerScoreParamsByName {
+		params = append(params, name)
+	}
+	return params
+}
+
+// GetPeerScoreParams returns the [pubsub.PeerScoreParams] for the given name.
+func GetPeerScoreParams(name string, blockTime uint64) (pubsub.PeerScoreParams, error) {
+	params, ok := PeerScoreParamsByName[name]
+	if !ok {
+		return pubsub.PeerScoreParams{}, fmt.Errorf("invalid params %s", name)
+	}
+
+	return params(blockTime), nil
+}
+
+// NewPeerScoreThresholds returns a default [pubsub.PeerScoreThresholds].
+// See [PeerScoreThresholds] for detailed documentation.
+//
+// [PeerScoreThresholds]: https://pkg.go.dev/github.com/libp2p/go-libp2p-pubsub@v0.8.1#PeerScoreThresholds
+func NewPeerScoreThresholds() pubsub.PeerScoreThresholds {
+	return pubsub.PeerScoreThresholds{
+		SkipAtomicValidation:        false,
+		GossipThreshold:             -10,
+		PublishThreshold:            -40,
+		GraylistThreshold:           -40,
+		AcceptPXThreshold:           20,
+		OpportunisticGraftThreshold: 0.05,
+	}
+}

op-node/p2p/peer_params_test.go

+package p2p
+
+import (
+	"math"
+	"sort"
+	"testing"
+	"time"
+
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/stretchr/testify/suite"
+)
+
+// PeerParamsTestSuite tests peer parameterization.
+type PeerParamsTestSuite struct {
+	suite.Suite
+}
+
+// TestPeerParams runs the PeerParamsTestSuite.
+func TestPeerParams(t *testing.T) {
+	suite.Run(t, new(PeerParamsTestSuite))
+}
+
+// TestPeerScoreConstants validates the peer score constants.
+func (testSuite *PeerParamsTestSuite) TestPeerScoreConstants() {
+	testSuite.Equal(0.01, DecayToZero)
+}
+
+// TestAvailablePeerScoreParams validates the available peer score parameters.
+func (testSuite *PeerParamsTestSuite) TestAvailablePeerScoreParams() {
+	available := AvailablePeerScoreParams()
+	sort.Strings(available)
+	expected := []string{"light", "none"}
+	testSuite.Equal(expected, available)
+}
+
+// TestNewPeerScoreThresholds validates the peer score thresholds.
+//
+// This is tested to ensure that the thresholds are not modified and missed in review.
+func (testSuite *PeerParamsTestSuite) TestNewPeerScoreThresholds() {
+	thresholds := NewPeerScoreThresholds()
+	expected := pubsub.PeerScoreThresholds{
+		SkipAtomicValidation:        false,
+		GossipThreshold:             -10,
+		PublishThreshold:            -40,
+		GraylistThreshold:           -40,
+		AcceptPXThreshold:           20,
+		OpportunisticGraftThreshold: 0.05,
+	}
+	testSuite.Equal(expected, thresholds)
+}
+
+// TestGetPeerScoreParams validates the peer score parameters.
+func (testSuite *PeerParamsTestSuite) TestGetPeerScoreParams() {
+	params, err := GetPeerScoreParams("light", 1)
+	testSuite.NoError(err)
+	expected := LightPeerScoreParams(1)
+	testSuite.Equal(expected.DecayInterval, params.DecayInterval)
+	testSuite.Equal(time.Duration(1)*time.Second, params.DecayInterval)
+
+	params, err = GetPeerScoreParams("none", 1)
+	testSuite.NoError(err)
+	expected = DisabledPeerScoreParams(1)
+	testSuite.Equal(expected.DecayInterval, params.DecayInterval)
+	testSuite.Equal(time.Duration(1)*time.Second, params.DecayInterval)
+
+	_, err = GetPeerScoreParams("invalid", 1)
+	testSuite.Error(err)
+}
+
+// TestLightPeerScoreParams validates the light peer score params.
+func (testSuite *PeerParamsTestSuite) TestLightPeerScoreParams() {
+	blockTime := uint64(1)
+	slot := time.Duration(blockTime) * time.Second
+	epoch := 6 * slot
+	oneHundredEpochs := 100 * epoch
+
+	// calculate the behavior penalty decay
+	duration := 10 * epoch
+	decay := math.Pow(DecayToZero, 1/float64(duration/slot))
+	testSuite.Equal(0.9261187281287935, decay)
+
+	// Test the params
+	params, err := GetPeerScoreParams("light", blockTime)
+	testSuite.NoError(err)
+	testSuite.Equal(params.Topics, make(map[string]*pubsub.TopicScoreParams))
+	testSuite.Equal(params.TopicScoreCap, float64(34))
+	// testSuite.Equal(params.AppSpecificScore("alice"), float(0))
+	testSuite.Equal(params.AppSpecificWeight, float64(1))
+	testSuite.Equal(params.IPColocationFactorWeight, float64(-35))
+	testSuite.Equal(params.IPColocationFactorThreshold, int(10))
+	testSuite.Nil(params.IPColocationFactorWhitelist)
+	testSuite.Equal(params.BehaviourPenaltyWeight, float64(-16))
+	testSuite.Equal(params.BehaviourPenaltyThreshold, float64(6))
+	testSuite.Equal(params.BehaviourPenaltyDecay, decay)
+	testSuite.Equal(params.DecayInterval, slot)
+	testSuite.Equal(params.DecayToZero, DecayToZero)
+	testSuite.Equal(params.RetainScore, oneHundredEpochs)
+}
+
+// TestDisabledPeerScoreParams validates the disabled peer score params.
+func (testSuite *PeerParamsTestSuite) TestDisabledPeerScoreParams() {
+	blockTime := uint64(1)
+	slot := time.Duration(blockTime) * time.Second
+	epoch := 6 * slot
+	oneHundredEpochs := 100 * epoch
+
+	// calculate the behavior penalty decay
+	duration := 10 * epoch
+	decay := math.Pow(DecayToZero, 1/float64(duration/slot))
+	testSuite.Equal(0.9261187281287935, decay)
+
+	// Test the params
+	params, err := GetPeerScoreParams("none", blockTime)
+	testSuite.NoError(err)
+	testSuite.Equal(params.Topics, make(map[string]*pubsub.TopicScoreParams))
+	testSuite.Equal(params.TopicScoreCap, float64(0))
+	testSuite.Equal(params.AppSpecificWeight, float64(1))
+	testSuite.Equal(params.IPColocationFactorWeight, float64(0))
+	testSuite.Nil(params.IPColocationFactorWhitelist)
+	testSuite.Equal(params.BehaviourPenaltyWeight, float64(0))
+	testSuite.Equal(params.BehaviourPenaltyDecay, decay)
+	testSuite.Equal(params.DecayInterval, slot)
+	testSuite.Equal(params.DecayToZero, DecayToZero)
+	testSuite.Equal(params.RetainScore, oneHundredEpochs)
+}
+
+// TestParamsZeroBlockTime validates peer score params use default slot for 0 block time.
+func (testSuite *PeerParamsTestSuite) TestParamsZeroBlockTime() {
+	slot := 2 * time.Second
+	params, err := GetPeerScoreParams("none", uint64(0))
+	testSuite.NoError(err)
+	testSuite.Equal(params.DecayInterval, slot)
+	params, err = GetPeerScoreParams("light", uint64(0))
+	testSuite.NoError(err)
+	testSuite.Equal(params.DecayInterval, slot)
+}

op-node/p2p/peer_scorer.go

+package p2p
+
+import (
+	log "github.com/ethereum/go-ethereum/log"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	peer "github.com/libp2p/go-libp2p/core/peer"
+)
+
+type scorer struct {
+	peerStore Peerstore
+	metricer  GossipMetricer
+	log       log.Logger
+	gater     PeerGater
+}
+
+// Peerstore is a subset of the libp2p peerstore.Peerstore interface.
+//
+//go:generate mockery --name Peerstore --output mocks/
+type Peerstore interface {
+	// PeerInfo returns a peer.PeerInfo struct for given peer.ID.
+	// This is a small slice of the information Peerstore has on
+	// that peer, useful to other services.
+	PeerInfo(peer.ID) peer.AddrInfo
+
+	// Peers returns all of the peer IDs stored across all inner stores.
+	Peers() peer.IDSlice
+}
+
+// Scorer is a peer scorer that scores peers based on application-specific metrics.
+type Scorer interface {
+	OnConnect()
+	OnDisconnect()
+	SnapshotHook() pubsub.ExtendedPeerScoreInspectFn
+}
+
+// NewScorer returns a new peer scorer.
+func NewScorer(peerGater PeerGater, peerStore Peerstore, metricer GossipMetricer, log log.Logger) Scorer {
+	return &scorer{
+		peerStore: peerStore,
+		metricer:  metricer,
+		log:       log,
+		gater:     peerGater,
+	}
+}
+
+// SnapshotHook returns a function that is called periodically by the pubsub library to inspect the peer scores.
+// It is passed into the pubsub library as a [pubsub.ExtendedPeerScoreInspectFn] in the [pubsub.WithPeerScoreInspect] option.
+// The returned [pubsub.ExtendedPeerScoreInspectFn] is called with a mapping of peer IDs to peer score snapshots.
+func (s *scorer) SnapshotHook() pubsub.ExtendedPeerScoreInspectFn {
+	return func(m map[peer.ID]*pubsub.PeerScoreSnapshot) {
+		for id, snap := range m {
+			// Record peer score in the metricer
+			s.metricer.RecordPeerScoring(id, snap.Score)
+
+			// Update with the peer gater
+			s.gater.Update(id, snap.Score)
+		}
+	}
+}
+
+// OnConnect is called when a peer connects.
+// See [p2p.NotificationsMetricer] for invocation.
+func (s *scorer) OnConnect() {
+	// no-op
+}
+
+// OnDisconnect is called when a peer disconnects.
+// See [p2p.NotificationsMetricer] for invocation.
+func (s *scorer) OnDisconnect() {
+	// no-op
+}

op-node/p2p/peer_scorer_test.go

+package p2p_test
+
+import (
+	"testing"
+
+	p2p "github.com/ethereum-optimism/optimism/op-node/p2p"
+	p2pMocks "github.com/ethereum-optimism/optimism/op-node/p2p/mocks"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	log "github.com/ethereum/go-ethereum/log"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	peer "github.com/libp2p/go-libp2p/core/peer"
+	suite "github.com/stretchr/testify/suite"
+)
+
+// PeerScorerTestSuite tests peer parameterization.
+type PeerScorerTestSuite struct {
+	suite.Suite
+
+	// mockConnGater *p2pMocks.ConnectionGater
+	mockGater    *p2pMocks.PeerGater
+	mockStore    *p2pMocks.Peerstore
+	mockMetricer *p2pMocks.GossipMetricer
+	logger       log.Logger
+}
+
+// SetupTest sets up the test suite.
+func (testSuite *PeerScorerTestSuite) SetupTest() {
+	testSuite.mockGater = &p2pMocks.PeerGater{}
+	// testSuite.mockConnGater = &p2pMocks.ConnectionGater{}
+	testSuite.mockStore = &p2pMocks.Peerstore{}
+	testSuite.mockMetricer = &p2pMocks.GossipMetricer{}
+	testSuite.logger = testlog.Logger(testSuite.T(), log.LvlError)
+}
+
+// TestPeerScorer runs the PeerScorerTestSuite.
+func TestPeerScorer(t *testing.T) {
+	suite.Run(t, new(PeerScorerTestSuite))
+}
+
+// TestPeerScorerOnConnect ensures we can call the OnConnect method on the peer scorer.
+func (testSuite *PeerScorerTestSuite) TestPeerScorerOnConnect() {
+	scorer := p2p.NewScorer(
+		testSuite.mockGater,
+		testSuite.mockStore,
+		testSuite.mockMetricer,
+		testSuite.logger,
+	)
+	scorer.OnConnect()
+}
+
+// TestPeerScorerOnDisconnect ensures we can call the OnDisconnect method on the peer scorer.
+func (testSuite *PeerScorerTestSuite) TestPeerScorerOnDisconnect() {
+	scorer := p2p.NewScorer(
+		testSuite.mockGater,
+		testSuite.mockStore,
+		testSuite.mockMetricer,
+		testSuite.logger,
+	)
+	scorer.OnDisconnect()
+}
+
+// TestSnapshotHook tests running the snapshot hook on the peer scorer.
+func (testSuite *PeerScorerTestSuite) TestSnapshotHook() {
+	scorer := p2p.NewScorer(
+		testSuite.mockGater,
+		testSuite.mockStore,
+		testSuite.mockMetricer,
+		testSuite.logger,
+	)
+	inspectFn := scorer.SnapshotHook()
+
+	// Mock the snapshot updates
+	// This doesn't return anything
+	testSuite.mockMetricer.On("RecordPeerScoring", peer.ID("peer1"), float64(-100)).Return(nil)
+
+	// Mock the peer gater call
+	testSuite.mockGater.On("Update", peer.ID("peer1"), float64(-100)).Return(nil)
+
+	// Apply the snapshot
+	snapshotMap := map[peer.ID]*pubsub.PeerScoreSnapshot{
+		peer.ID("peer1"): {
+			Score: -100,
+		},
+	}
+	inspectFn(snapshotMap)
+}
+
+// TestSnapshotHookBlockPeer tests running the snapshot hook on the peer scorer with a peer score below the threshold.
+// This implies that the peer should be blocked.
+func (testSuite *PeerScorerTestSuite) TestSnapshotHookBlockPeer() {
+	scorer := p2p.NewScorer(
+		testSuite.mockGater,
+		testSuite.mockStore,
+		testSuite.mockMetricer,
+		testSuite.logger,
+	)
+	inspectFn := scorer.SnapshotHook()
+
+	// Mock the snapshot updates
+	// This doesn't return anything
+	testSuite.mockMetricer.On("RecordPeerScoring", peer.ID("peer1"), float64(-101)).Return(nil)
+
+	// Mock the peer gater call
+	testSuite.mockGater.On("Update", peer.ID("peer1"), float64(-101)).Return(nil)
+
+	// Apply the snapshot
+	snapshotMap := map[peer.ID]*pubsub.PeerScoreSnapshot{
+		peer.ID("peer1"): {
+			Score: -101,
+		},
+	}
+	inspectFn(snapshotMap)
+}

op-node/p2p/peer_scores.go

+package p2p
+
+import (
+	log "github.com/ethereum/go-ethereum/log"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	host "github.com/libp2p/go-libp2p/core/host"
+)
+
+// ConfigurePeerScoring configures the peer scoring parameters for the pubsub
+func ConfigurePeerScoring(h host.Host, g ConnectionGater, gossipConf GossipSetupConfigurables, m GossipMetricer, log log.Logger) []pubsub.Option {
+	// If we want to completely disable scoring config here, we can use the [peerScoringParams]
+	// to return early without returning any [pubsub.Option].
+	peerScoreParams := gossipConf.PeerScoringParams()
+	peerScoreThresholds := NewPeerScoreThresholds()
+	banEnabled := gossipConf.BanPeers()
+	peerGater := NewPeerGater(g, log, banEnabled)
+	scorer := NewScorer(peerGater, h.Peerstore(), m, log)
+	opts := []pubsub.Option{}
+	// Check the app specific score since libp2p doesn't export it's [validate] function :/
+	if peerScoreParams != nil && peerScoreParams.AppSpecificScore != nil {
+		opts = []pubsub.Option{
+			pubsub.WithPeerScore(peerScoreParams, &peerScoreThresholds),
+			pubsub.WithPeerScoreInspect(scorer.SnapshotHook(), peerScoreInspectFrequency),
+		}
+	} else {
+		log.Warn("Proceeding with no peer scoring...\nMissing AppSpecificScore in peer scoring params")
+	}
+	return opts
+}

op-node/p2p/peer_scores_test.go

+package p2p_test
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"testing"
+	"time"
+
+	p2p "github.com/ethereum-optimism/optimism/op-node/p2p"
+	p2pMocks "github.com/ethereum-optimism/optimism/op-node/p2p/mocks"
+	testlog "github.com/ethereum-optimism/optimism/op-node/testlog"
+
+	mock "github.com/stretchr/testify/mock"
+	suite "github.com/stretchr/testify/suite"
+
+	log "github.com/ethereum/go-ethereum/log"
+
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	host "github.com/libp2p/go-libp2p/core/host"
+	peer "github.com/libp2p/go-libp2p/core/peer"
+	bhost "github.com/libp2p/go-libp2p/p2p/host/blank"
+	tswarm "github.com/libp2p/go-libp2p/p2p/net/swarm/testing"
+)
+
+// PeerScoresTestSuite tests peer parameterization.
+type PeerScoresTestSuite struct {
+	suite.Suite
+
+	mockGater    *p2pMocks.ConnectionGater
+	mockStore    *p2pMocks.Peerstore
+	mockMetricer *p2pMocks.GossipMetricer
+	logger       log.Logger
+}
+
+// SetupTest sets up the test suite.
+func (testSuite *PeerScoresTestSuite) SetupTest() {
+	testSuite.mockGater = &p2pMocks.ConnectionGater{}
+	testSuite.mockStore = &p2pMocks.Peerstore{}
+	testSuite.mockMetricer = &p2pMocks.GossipMetricer{}
+	testSuite.logger = testlog.Logger(testSuite.T(), log.LvlError)
+}
+
+// TestPeerScores runs the PeerScoresTestSuite.
+func TestPeerScores(t *testing.T) {
+	suite.Run(t, new(PeerScoresTestSuite))
+}
+
+// getNetHosts generates a slice of hosts using the [libp2p/go-libp2p] library.
+func getNetHosts(testSuite *PeerScoresTestSuite, ctx context.Context, n int) []host.Host {
+	var out []host.Host
+	for i := 0; i < n; i++ {
+		netw := tswarm.GenSwarm(testSuite.T())
+		h := bhost.NewBlankHost(netw)
+		testSuite.T().Cleanup(func() { h.Close() })
+		out = append(out, h)
+	}
+	return out
+}
+
+func newGossipSubs(testSuite *PeerScoresTestSuite, ctx context.Context, hosts []host.Host) []*pubsub.PubSub {
+	var psubs []*pubsub.PubSub
+
+	logger := testlog.Logger(testSuite.T(), log.LvlCrit)
+
+	// For each host, create a default gossipsub router.
+	for _, h := range hosts {
+		rt := pubsub.DefaultGossipSubRouter(h)
+		opts := []pubsub.Option{}
+		opts = append(opts, p2p.ConfigurePeerScoring(h, testSuite.mockGater, &p2p.Config{
+			PeerScoring: pubsub.PeerScoreParams{
+				AppSpecificScore: func(p peer.ID) float64 {
+					if p == hosts[0].ID() {
+						return -1000
+					} else {
+						return 0
+					}
+				},
+				AppSpecificWeight: 1,
+				DecayInterval:     time.Second,
+				DecayToZero:       0.01,
+			},
+		}, testSuite.mockMetricer, logger)...)
+		ps, err := pubsub.NewGossipSubWithRouter(ctx, h, rt, opts...)
+		if err != nil {
+			panic(err)
+		}
+		psubs = append(psubs, ps)
+	}
+
+	return psubs
+}
+
+func connectHosts(t *testing.T, hosts []host.Host, d int) {
+	for i, a := range hosts {
+		for j := 0; j < d; j++ {
+			n := rand.Intn(len(hosts))
+			if n == i {
+				j--
+				continue
+			}
+
+			b := hosts[n]
+
+			pinfo := a.Peerstore().PeerInfo(a.ID())
+			err := b.Connect(context.Background(), pinfo)
+			if err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+}
+
+// TestNegativeScores tests blocking peers with negative scores.
+//
+// This follows the testing done in libp2p's gossipsub_test.go [TestGossipsubNegativeScore] function.
+func (testSuite *PeerScoresTestSuite) TestNegativeScores() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	testSuite.mockMetricer.On("RecordPeerScoring", mock.Anything, float64(0)).Return(nil)
+	testSuite.mockMetricer.On("RecordPeerScoring", mock.Anything, float64(-1000)).Return(nil)
+
+	testSuite.mockGater.On("ListBlockedPeers").Return([]peer.ID{})
+
+	// Construct 20 hosts using the [getNetHosts] function.
+	hosts := getNetHosts(testSuite, ctx, 20)
+	testSuite.Equal(20, len(hosts))
+
+	// Construct 20 gossipsub routers using the [newGossipSubs] function.
+	pubsubs := newGossipSubs(testSuite, ctx, hosts)
+	testSuite.Equal(20, len(pubsubs))
+
+	// Connect the hosts in a dense network
+	connectHosts(testSuite.T(), hosts, 10)
+
+	// Create subscriptions
+	var subs []*pubsub.Subscription
+	var topics []*pubsub.Topic
+	for _, ps := range pubsubs {
+		topic, err := ps.Join("test")
+		testSuite.NoError(err)
+		sub, err := topic.Subscribe()
+		testSuite.NoError(err)
+		subs = append(subs, sub)
+		topics = append(topics, topic)
+	}
+
+	// Wait and then publish messages
+	time.Sleep(3 * time.Second)
+	for i := 0; i < 20; i++ {
+		msg := []byte(fmt.Sprintf("message %d", i))
+		topic := topics[i]
+		err := topic.Publish(ctx, msg)
+		testSuite.NoError(err)
+		time.Sleep(20 * time.Millisecond)
+	}
+
+	// Allow gossip to propagate
+	time.Sleep(2 * time.Second)
+
+	// Collects all messages from a subscription
+	collectAll := func(sub *pubsub.Subscription) []*pubsub.Message {
+		var res []*pubsub.Message
+		ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+		defer cancel()
+		for {
+			msg, err := sub.Next(ctx)
+			if err != nil {
+				break
+			}
+			res = append(res, msg)
+		}
+		return res
+	}
+
+	// Collect messages for the first host subscription
+	// This host should only receive 1 message from itself
+	count := len(collectAll(subs[0]))
+	testSuite.Equal(1, count)
+
+	// Validate that all messages were received from the first peer
+	for _, sub := range subs[1:] {
+		all := collectAll(sub)
+		for _, m := range all {
+			testSuite.NotEqual(hosts[0].ID(), m.ReceivedFrom)
+		}
+	}
+}

op-node/p2p/prepared.go

@@ -64,6 +64,18 @@ func (p *Prepared) ConfigureGossip(params *pubsub.GossipSubParams) []pubsub.Opti
 	return nil
 }
 
+func (p *Prepared) PeerScoringParams() *pubsub.PeerScoreParams {
+	return nil
+}
+
+func (p *Prepared) BanPeers() bool {
+	return false
+}
+
+func (p *Prepared) TopicScoringParams() *pubsub.TopicScoreParams {
+	return nil
+}
+
 func (p *Prepared) Disabled() bool {
 	return false
 }

op-node/p2p/rpc_server.go

@@ -30,9 +30,9 @@ import (
 // - banning peers based on score
 
 var (
-	DisabledDiscovery   = errors.New("discovery disabled")
-	NoConnectionManager = errors.New("no connection manager")
-	NoConnectionGater   = errors.New("no connection gater")
+	ErrDisabledDiscovery   = errors.New("discovery disabled")
+	ErrNoConnectionManager = errors.New("no connection manager")
+	ErrNoConnectionGater   = errors.New("no connection gater")
 )
 
 type Node interface {
@@ -236,7 +236,7 @@ func (s *APIBackend) DiscoveryTable(_ context.Context) ([]*enode.Node, error) {
 	if dv5 := s.node.Dv5Udp(); dv5 != nil {
 		return dv5.AllNodes(), nil
 	} else {
-		return nil, DisabledDiscovery
+		return nil, ErrDisabledDiscovery
 	}
 }
 
@@ -244,7 +244,7 @@ func (s *APIBackend) BlockPeer(_ context.Context, p peer.ID) error {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_blockPeer")
 	defer recordDur()
 	if gater := s.node.ConnectionGater(); gater == nil {
-		return NoConnectionGater
+		return ErrNoConnectionGater
 	} else {
 		return gater.BlockPeer(p)
 	}
@@ -254,7 +254,7 @@ func (s *APIBackend) UnblockPeer(_ context.Context, p peer.ID) error {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_unblockPeer")
 	defer recordDur()
 	if gater := s.node.ConnectionGater(); gater == nil {
-		return NoConnectionGater
+		return ErrNoConnectionGater
 	} else {
 		return gater.UnblockPeer(p)
 	}
@@ -264,7 +264,7 @@ func (s *APIBackend) ListBlockedPeers(_ context.Context) ([]peer.ID, error) {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_listBlockedPeers")
 	defer recordDur()
 	if gater := s.node.ConnectionGater(); gater == nil {
-		return nil, NoConnectionGater
+		return nil, ErrNoConnectionGater
 	} else {
 		return gater.ListBlockedPeers(), nil
 	}
@@ -276,7 +276,7 @@ func (s *APIBackend) BlockAddr(_ context.Context, ip net.IP) error {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_blockAddr")
 	defer recordDur()
 	if gater := s.node.ConnectionGater(); gater == nil {
-		return NoConnectionGater
+		return ErrNoConnectionGater
 	} else {
 		return gater.BlockAddr(ip)
 	}
@@ -286,7 +286,7 @@ func (s *APIBackend) UnblockAddr(_ context.Context, ip net.IP) error {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_unblockAddr")
 	defer recordDur()
 	if gater := s.node.ConnectionGater(); gater == nil {
-		return NoConnectionGater
+		return ErrNoConnectionGater
 	} else {
 		return gater.UnblockAddr(ip)
 	}
@@ -296,7 +296,7 @@ func (s *APIBackend) ListBlockedAddrs(_ context.Context) ([]net.IP, error) {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_listBlockedAddrs")
 	defer recordDur()
 	if gater := s.node.ConnectionGater(); gater == nil {
-		return nil, NoConnectionGater
+		return nil, ErrNoConnectionGater
 	} else {
 		return gater.ListBlockedAddrs(), nil
 	}
@@ -308,7 +308,7 @@ func (s *APIBackend) BlockSubnet(_ context.Context, ipnet *net.IPNet) error {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_blockSubnet")
 	defer recordDur()
 	if gater := s.node.ConnectionGater(); gater == nil {
-		return NoConnectionGater
+		return ErrNoConnectionGater
 	} else {
 		return gater.BlockSubnet(ipnet)
 	}
@@ -318,7 +318,7 @@ func (s *APIBackend) UnblockSubnet(_ context.Context, ipnet *net.IPNet) error {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_unblockSubnet")
 	defer recordDur()
 	if gater := s.node.ConnectionGater(); gater == nil {
-		return NoConnectionGater
+		return ErrNoConnectionGater
 	} else {
 		return gater.UnblockSubnet(ipnet)
 	}
@@ -328,7 +328,7 @@ func (s *APIBackend) ListBlockedSubnets(_ context.Context) ([]*net.IPNet, error)
 	recordDur := s.m.RecordRPCServerRequest("opp2p_listBlockedSubnets")
 	defer recordDur()
 	if gater := s.node.ConnectionGater(); gater == nil {
-		return nil, NoConnectionGater
+		return nil, ErrNoConnectionGater
 	} else {
 		return gater.ListBlockedSubnets(), nil
 	}
@@ -338,7 +338,7 @@ func (s *APIBackend) ProtectPeer(_ context.Context, p peer.ID) error {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_protectPeer")
 	defer recordDur()
 	if manager := s.node.ConnectionManager(); manager == nil {
-		return NoConnectionManager
+		return ErrNoConnectionManager
 	} else {
 		manager.Protect(p, "api-protected")
 		return nil
@@ -349,7 +349,7 @@ func (s *APIBackend) UnprotectPeer(_ context.Context, p peer.ID) error {
 	recordDur := s.m.RecordRPCServerRequest("opp2p_unprotectPeer")
 	defer recordDur()
 	if manager := s.node.ConnectionManager(); manager == nil {
-		return NoConnectionManager
+		return ErrNoConnectionManager
 	} else {
 		manager.Unprotect(p, "api-protected")
 		return nil

op-node/p2p/topic_params.go

+package p2p
+
+import (
+	"fmt"
+	"time"
+
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+)
+
+// MeshWeight is the weight of the mesh delivery topic.
+const MeshWeight = -0.7
+
+// MaxInMeshScore is the maximum score for being in the mesh.
+const MaxInMeshScore = 10
+
+// DecayEpoch is the number of epochs to decay the score over.
+const DecayEpoch = time.Duration(5)
+
+// LightTopicScoreParams is a default instantiation of [pubsub.TopicScoreParams].
+// See [TopicScoreParams] for detailed documentation.
+//
+// [TopicScoreParams]: https://pkg.go.dev/github.com/libp2p/go-libp2p-pubsub@v0.8.1#TopicScoreParams
+var LightTopicScoreParams = func(blockTime uint64) pubsub.TopicScoreParams {
+	slot := time.Duration(blockTime) * time.Second
+	if slot == 0 {
+		slot = 2 * time.Second
+	}
+	epoch := 6 * slot
+	invalidDecayPeriod := 50 * epoch
+	return pubsub.TopicScoreParams{
+		TopicWeight:                     0.8,
+		TimeInMeshWeight:                MaxInMeshScore / inMeshCap(slot),
+		TimeInMeshQuantum:               slot,
+		TimeInMeshCap:                   inMeshCap(slot),
+		FirstMessageDeliveriesWeight:    1,
+		FirstMessageDeliveriesDecay:     ScoreDecay(20*epoch, slot),
+		FirstMessageDeliveriesCap:       23,
+		MeshMessageDeliveriesWeight:     MeshWeight,
+		MeshMessageDeliveriesDecay:      ScoreDecay(DecayEpoch*epoch, slot),
+		MeshMessageDeliveriesCap:        float64(uint64(epoch/slot) * uint64(DecayEpoch)),
+		MeshMessageDeliveriesThreshold:  float64(uint64(epoch/slot) * uint64(DecayEpoch) / 10),
+		MeshMessageDeliveriesWindow:     2 * time.Second,
+		MeshMessageDeliveriesActivation: 4 * epoch,
+		MeshFailurePenaltyWeight:        MeshWeight,
+		MeshFailurePenaltyDecay:         ScoreDecay(DecayEpoch*epoch, slot),
+		InvalidMessageDeliveriesWeight:  -140.4475,
+		InvalidMessageDeliveriesDecay:   ScoreDecay(invalidDecayPeriod, slot),
+	}
+}
+
+// the cap for `inMesh` time scoring.
+func inMeshCap(slot time.Duration) float64 {
+	return float64((3600 * time.Second) / slot)
+}
+
+// DisabledTopicScoreParams is an instantiation of [pubsub.TopicScoreParams] where all scoring is disabled.
+// See [TopicScoreParams] for detailed documentation.
+//
+// [TopicScoreParams]: https://pkg.go.dev/github.com/libp2p/go-libp2p-pubsub@v0.8.1#TopicScoreParams
+var DisabledTopicScoreParams = func(blockTime uint64) pubsub.TopicScoreParams {
+	slot := time.Duration(blockTime) * time.Second
+	if slot == 0 {
+		slot = 2 * time.Second
+	}
+	epoch := 6 * slot
+	invalidDecayPeriod := 50 * epoch
+	return pubsub.TopicScoreParams{
+		TopicWeight:                     0, // disabled
+		TimeInMeshWeight:                0, // disabled
+		TimeInMeshQuantum:               slot,
+		TimeInMeshCap:                   inMeshCap(slot),
+		FirstMessageDeliveriesWeight:    0, // disabled
+		FirstMessageDeliveriesDecay:     ScoreDecay(20*epoch, slot),
+		FirstMessageDeliveriesCap:       23,
+		MeshMessageDeliveriesWeight:     0, // disabled
+		MeshMessageDeliveriesDecay:      ScoreDecay(DecayEpoch*epoch, slot),
+		MeshMessageDeliveriesCap:        float64(uint64(epoch/slot) * uint64(DecayEpoch)),
+		MeshMessageDeliveriesThreshold:  float64(uint64(epoch/slot) * uint64(DecayEpoch) / 10),
+		MeshMessageDeliveriesWindow:     2 * time.Second,
+		MeshMessageDeliveriesActivation: 4 * epoch,
+		MeshFailurePenaltyWeight:        0, // disabled
+		MeshFailurePenaltyDecay:         ScoreDecay(DecayEpoch*epoch, slot),
+		InvalidMessageDeliveriesWeight:  0, // disabled
+		InvalidMessageDeliveriesDecay:   ScoreDecay(invalidDecayPeriod, slot),
+	}
+}
+
+// TopicScoreParamsByName is a map of name to [pubsub.TopicScoreParams].
+var TopicScoreParamsByName = map[string](func(blockTime uint64) pubsub.TopicScoreParams){
+	"light": LightTopicScoreParams,
+	"none":  DisabledTopicScoreParams,
+}
+
+// AvailableTopicScoreParams returns a list of available topic score params.
+// These can be used as an input to [GetTopicScoreParams] which returns the
+// corresponding [pubsub.TopicScoreParams].
+func AvailableTopicScoreParams() []string {
+	var params []string
+	for name := range TopicScoreParamsByName {
+		params = append(params, name)
+	}
+	return params
+}
+
+// GetTopicScoreParams returns the [pubsub.TopicScoreParams] for the given name.
+func GetTopicScoreParams(name string, blockTime uint64) (pubsub.TopicScoreParams, error) {
+	params, ok := TopicScoreParamsByName[name]
+	if !ok {
+		return pubsub.TopicScoreParams{}, fmt.Errorf("invalid topic params %s", name)
+	}
+
+	return params(blockTime), nil
+}

op-node/rollup/derive/engine_queue.go

@@ -104,7 +104,7 @@ type EngineQueue struct {
 
 	finalizedL1 eth.L1BlockRef
 
-	safeAttributes []*eth.PayloadAttributes
+	safeAttributes *eth.PayloadAttributes
 	unsafePayloads PayloadsQueue // queue of unsafe payloads, ordered by ascending block number, may have gaps
 
 	// Tracks which L2 blocks where last derived from which L1 block. At most finalityLookback large.
@@ -167,11 +167,6 @@ func (eq *EngineQueue) AddUnsafePayload(payload *eth.ExecutionPayload) {
 	eq.log.Trace("Next unsafe payload to process", "next", p.ID(), "timestamp", uint64(p.Timestamp))
 }
 
-func (eq *EngineQueue) AddSafeAttributes(attributes *eth.PayloadAttributes) {
-	eq.log.Trace("Adding next safe attributes", "timestamp", attributes.Timestamp)
-	eq.safeAttributes = append(eq.safeAttributes, attributes)
-}
-
 func (eq *EngineQueue) Finalize(l1Origin eth.L1BlockRef) {
 	if l1Origin.Number < eq.finalizedL1.Number {
 		eq.log.Error("ignoring old L1 finalized block signal! Is the L1 provider corrupted?", "prev_finalized_l1", eq.finalizedL1, "signaled_finalized_l1", l1Origin)
@@ -212,27 +207,27 @@ func (eq *EngineQueue) Step(ctx context.Context) error {
 	if eq.needForkchoiceUpdate {
 		return eq.tryUpdateEngine(ctx)
 	}
-	if len(eq.safeAttributes) > 0 {
+	if eq.safeAttributes != nil {
 		return eq.tryNextSafeAttributes(ctx)
 	}
 	outOfData := false
-	if len(eq.safeAttributes) == 0 {
-		newOrigin := eq.prev.Origin()
-		// Check if the L2 unsafe head origin is consistent with the new origin
-		if err := eq.verifyNewL1Origin(ctx, newOrigin); err != nil {
-			return err
-		}
-		eq.origin = newOrigin
-		eq.postProcessSafeL2() // make sure we track the last L2 safe head for every new L1 block
-		if next, err := eq.prev.NextAttributes(ctx, eq.safeHead); err == io.EOF {
-			outOfData = true
-		} else if err != nil {
-			return err
-		} else {
-			eq.safeAttributes = append(eq.safeAttributes, next)
-			return NotEnoughData
-		}
+	newOrigin := eq.prev.Origin()
+	// Check if the L2 unsafe head origin is consistent with the new origin
+	if err := eq.verifyNewL1Origin(ctx, newOrigin); err != nil {
+		return err
+	}
+	eq.origin = newOrigin
+	eq.postProcessSafeL2() // make sure we track the last L2 safe head for every new L1 block
+	if next, err := eq.prev.NextAttributes(ctx, eq.safeHead); err == io.EOF {
+		outOfData = true
+	} else if err != nil {
+		return err
+	} else {
+		eq.safeAttributes = next
+		eq.log.Debug("Adding next safe attributes", "safe_head", eq.safeHead, "next", eq.safeAttributes)
+		return NotEnoughData
 	}
+
 	if eq.unsafePayloads.Len() > 0 {
 		return eq.tryNextUnsafePayload(ctx)
 	}
@@ -459,7 +454,7 @@ func (eq *EngineQueue) consolidateNextSafeAttributes(ctx context.Context) error
 		}
 		return NewTemporaryError(fmt.Errorf("failed to get existing unsafe payload to compare against derived attributes from L1: %w", err))
 	}
-	if err := AttributesMatchBlock(eq.safeAttributes[0], eq.safeHead.Hash, payload, eq.log); err != nil {
+	if err := AttributesMatchBlock(eq.safeAttributes, eq.safeHead.Hash, payload, eq.log); err != nil {
 		eq.log.Warn("L2 reorg: existing unsafe block does not match derived attributes from L1", "err", err)
 		// geth cannot wind back a chain without reorging to a new, previously non-canonical, block
 		return eq.forceNextSafeAttributes(ctx)
@@ -472,7 +467,7 @@ func (eq *EngineQueue) consolidateNextSafeAttributes(ctx context.Context) error
 	eq.needForkchoiceUpdate = true
 	eq.metrics.RecordL2Ref("l2_safe", ref)
 	// unsafe head stays the same, we did not reorg the chain.
-	eq.safeAttributes = eq.safeAttributes[1:]
+	eq.safeAttributes = nil
 	eq.postProcessSafeL2()
 	eq.logSyncProgress("reconciled with L1")
 
@@ -481,10 +476,10 @@ func (eq *EngineQueue) consolidateNextSafeAttributes(ctx context.Context) error
 
 // forceNextSafeAttributes inserts the provided attributes, reorging away any conflicting unsafe chain.
 func (eq *EngineQueue) forceNextSafeAttributes(ctx context.Context) error {
-	if len(eq.safeAttributes) == 0 {
+	if eq.safeAttributes == nil {
 		return nil
 	}
-	attrs := eq.safeAttributes[0]
+	attrs := eq.safeAttributes
 	errType, err := eq.StartPayload(ctx, eq.safeHead, attrs, true)
 	if err == nil {
 		_, errType, err = eq.ConfirmPayload(ctx)
@@ -513,7 +508,7 @@ func (eq *EngineQueue) forceNextSafeAttributes(ctx context.Context) error {
 				return NewCriticalError(fmt.Errorf("failed to process block with only deposit transactions: %w", err))
 			}
 			// drop the payload without inserting it
-			eq.safeAttributes = eq.safeAttributes[1:]
+			eq.safeAttributes = nil
 			// suppress the error b/c we want to retry with the next batch from the batch queue
 			// If there is no valid batch the node will eventually force a deposit only block. If
 			// the deposit only block fails, this will return the critical error above.
@@ -523,7 +518,7 @@ func (eq *EngineQueue) forceNextSafeAttributes(ctx context.Context) error {
 			return NewCriticalError(fmt.Errorf("unknown InsertHeadBlock error type %d: %w", errType, err))
 		}
 	}
-	eq.safeAttributes = eq.safeAttributes[1:]
+	eq.safeAttributes = nil
 	eq.logSyncProgress("processed safe block derived from L1")
 
 	return nil

op-node/rollup/derive/pipeline.go

@@ -50,7 +50,6 @@ type EngineQueueStage interface {
 	SetUnsafeHead(head eth.L2BlockRef)
 
 	Finalize(l1Origin eth.L1BlockRef)
-	AddSafeAttributes(attributes *eth.PayloadAttributes)
 	AddUnsafePayload(payload *eth.ExecutionPayload)
 	Step(context.Context) error
 }

op-node/service.go

@@ -46,7 +46,7 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*node.Config, error) {
 		return nil, fmt.Errorf("failed to load p2p signer: %w", err)
 	}
 
-	p2pConfig, err := p2pcli.NewConfig(ctx)
+	p2pConfig, err := p2pcli.NewConfig(ctx, rollupConfig.BlockTime)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load p2p config: %w", err)
 	}

op-node/sources/batching.go

@@ -115,7 +115,6 @@ func (ibc *IterativeBatchCall[K, V]) Fetch(ctx context.Context) error {
 			}
 			return ctx.Err()
 		default:
-			break
 		}
 		break
 	}

packages/atst/README.md

@@ -16,9 +16,9 @@
 
 # atst
 
-atst is a typescript sdk and cli around the attestation station
+atst is a typescript / javascript sdk and cli around AttestationStation
 
-### Visit [Docs](https://community.optimism.io/docs/governance/attestation-station/) for general documentation on the attestation station!
+**Visit [Docs](https://community.optimism.io/docs/governance/attestation-station/) for general documentation on AttestationStation.**
 
 ## Getting started
 
@@ -28,42 +28,50 @@ Install
 npm install @eth-optimism/atst wagmi @wagmi/core ethers@5.7.0
 ```
 
-## atst typescript sdk
+## atst typescript/javascript sdk
 
-The typescript sdk provides a clean [wagmi](https://wagmi.sh/) based interface for reading and writing to the attestation station
+The typescript sdk provides a clean [wagmi](https://wagmi.sh/) based interface for reading and writing to AttestationStation.
 
-### See [sdk docs](https://github.com/ethereum-optimism/optimism/blob/develop/packages/atst/docs/sdk.md) for usage instructions
+**See [sdk docs](https://github.com/ethereum-optimism/optimism/blob/develop/packages/atst/docs/sdk.md) for usage instructions.**
 
 ## atst cli
 
-The cli provides a convenient cli for interacting with the attestation station contract
+The cli provides a convenient cli for interacting with the AttestationStation contract
 
 ![preview](./assets/preview.gif)
 
-## React API
+**See [cli docs](https://github.com/ethereum-optimism/optimism/blob/develop/packages/atst/docs/cli.md) for usage instructions.**
 
-For react hooks we recomend using the [wagmi cli](https://wagmi.sh/cli/getting-started) with the [etherscan plugin](https://wagmi.sh/cli/plugins/etherscan) and [react plugin](https://wagmi.sh/cli/plugins/react) to automatically generate react hooks around the attestation station.
+## React API
 
-Use `createKey` and `createValue` to convert your raw keys and values into bytes that can be used in the attestation station contract calls
+For react hooks we recomend using the [wagmi cli](https://wagmi.sh/cli/getting-started) with the [etherscan plugin](https://wagmi.sh/cli/plugins/etherscan) and [react plugin](https://wagmi.sh/cli/plugins/react) to automatically generate react hooks around AttestationStation.
 
-Use `parseString`, `parseBool`, `parseAddress` and `parseNumber` to convert values returned by attestation station to their correct data type.
+Use `createKey` and `createValue` to convert your raw keys and values into bytes that can be used in AttestationStation contract calls
 
-For convenience we also export the hooks here.
+Use `parseString`, `parseBool`, `parseAddress` and `parseNumber` to convert values returned by AttestationStation to their correct data type.
 
-`useAttestationStationAttestation` - Reads attestations with useContractRead
+For convenience we also [export the hooks here](https://github.com/ethereum-optimism/optimism/blob/develop/packages/atst/src/index.ts):
+- `useAttestationStationAttestation` - Reads attestations with useContractRead
+- `useAttestationStationVersion` - Reads attestation version
+- `useAttestationStationAttest` - Wraps useContractWrite with AttestationStation abi calling attest
+- `usePrepareAttestationStationAttest` - Wraps usePrepare with AttestationStation abi calling attest
+- `useAttestationStationAttestationCreatedEvent` - Wraps useContractEvents for Created events
 
-`useAttestationStationVersion` - Reads attestation version
+Also some more hooks exported by the cli but these are likely the only ones you need.
 
-`useAttestationStationAttest` - Wraps useContractWrite with attestation station abi calling attest
+## Contributing
 
-`usePrepareAttestationStationAttest` - Wraps usePrepare with attestation station abi calling attest
+Please see our [contributing.md](https://github.com/ethereum-optimism/optimism/blob/develop/CONTRIBUTING.md). No contribution is too small.
 
-`useAttestationStationAttestationCreatedEvent` - Wraps useContractEvents for Created events
+Having your contribution denied feels bad. 
+Please consider [opening an issue](https://github.com/ethereum-optimism/optimism/issues) before adding any new features or apis.
 
-Also some more hooks exported by the cli but these are likely the only ones you need.
 
-## Contributing
+## Getting help
 
-Please see our [contributing.md](docs/contributing.md). No contribution is too small.
+If you have any problems, these resources could help you:
 
-Having your contribution denied feels bad. Please consider opening an issue before adding any new features or apis
+- [sdk documentation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/atst/docs/sdk.md)
+- [cli documentation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/atst/docs/cli.md)
+- [Optimism Discord](https://discord-gateway.optimism.io/)
+- [Telegram group](https://t.me/+zwpJ8Ohqgl8yNjNh) 

packages/atst/docs/cli.md

@@ -63,9 +63,9 @@ npx atst read --key "optimist.base-uri" --about 0x2335022c740d17c2837f9C884Bfe4f
 Example: 
 
 ```bash
-atst write --key "optimist.base-uri" \
+npx atst write --key "optimist.base-uri" \
     --about 0x2335022c740d17c2837f9C884Bfe4fFdbf0A95D5 \
     --value "my attestation" \
     --private-key 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 \
-    --rpc-url http://localhost:8545
+    --rpc-url http://goerli.optimism.io
 ```

packages/atst/docs/sdk.md

-# atst sdk docs
+# AttestationStation sdk docs
 
 Typescript sdk for interacting with the ATST based on [@wagmi/core](https://wagmi.sh/core/getting-started)
 
@@ -150,7 +150,7 @@ const attestation = await readAttestation(
   about,          // Address: The about topic of the attestation
   key,            // string: The key of the attestation
   dataType,       // Optional, the data type of the attestation, 'string' | 'bytes' | 'number' | 'bool' | 'address'
-  contractAddress // Optional address: the contract address of the attestation station
+  contractAddress // Optional address: the contract address of AttestationStation
 )
 ```
 
@@ -193,7 +193,7 @@ These definitions allow you to communicate with AttestationStation, but are not
 #### `ATTESTATION_STATION_ADDRESS`
 
 
-The deployment address for the attestation station currently deployed with create2 on Optimism and Optimism Goerli `0xEE36eaaD94d1Cc1d0eccaDb55C38bFfB6Be06C77`.
+The deployment address for AttestationStation currently deployed with create2 on Optimism and Optimism Goerli `0xEE36eaaD94d1Cc1d0eccaDb55C38bFfB6Be06C77`.
 
 ```typescript
 import { ATTESTATION_STATION_ADDRESS } from '@eth-optimism/atst'
@@ -201,7 +201,7 @@ import { ATTESTATION_STATION_ADDRESS } from '@eth-optimism/atst'
 
 #### `abi`
 
-The abi of the attestation station contract
+The abi of the AttestationStation contract
 
 ```typescript
 import { abi } from '@eth-optimism/atst'
@@ -265,24 +265,26 @@ const bigNumberAttestation = stringifyAttestationBytes(
 )
 ```
 
-**Note:** `writeAttestation` already does this for you so this is only needed if using a library other than the attestation station.
+**Note:** `writeAttestation` already does this for you so this is only needed if using a library other than `atst`.
 
 ### React API
 
-For react hooks we recomend using the [wagmi cli](https://wagmi.sh/cli/getting-started) with the [etherscan plugin](https://wagmi.sh/cli/plugins/etherscan) and [react plugin](https://wagmi.sh/cli/plugins/react) to automatically generate react hooks around the attestation station.
+For react hooks we recomend using the [wagmi cli](https://wagmi.sh/cli/getting-started) with the [etherscan plugin](https://wagmi.sh/cli/plugins/etherscan) and [react plugin](https://wagmi.sh/cli/plugins/react) to automatically generate react hooks around AttestationStation.
 
-Use `createKey` and `createValue` to convert your raw keys and values into bytes that can be used in the attestation station contract calls.
-Use `parseString`, `parseBool`, `parseAddress` and `parseNumber` to convert values returned by attestation station to their correct data type.
+Use `createKey` and `createValue` to convert your raw keys and values into bytes that can be used in AttestationStation contract calls.
+Use `parseString`, `parseBool`, `parseAddress` and `parseNumber` to convert values returned by AttestationStation to their correct data type.
 
-For convenience we also [export the hooks](../src/react.ts) here:
+For convenience we also [export the hooks here](../src/react.ts):
 - `useAttestationStationAttestation` - Reads attestations with useContractRead
 - `useAttestationStationVersion` - Reads attestation version
-- `useAttestationStationAttest` - Wraps useContractWrite with attestation station abi calling attest
-- `usePrepareAttestationStationAttest` - Wraps usePrepare with attestation station abi calling attest
+- `useAttestationStationAttest` - Wraps useContractWrite with AttestationStation abi calling attest
+- `usePrepareAttestationStationAttest` - Wraps usePrepare with AttestationStation abi calling attest
 - `useAttestationStationAttestationCreatedEvent` - Wraps useContractEvents for Created events
 
 
 
 ## Tutorial
 
-For a tutorial on using the attestation station in general, see out tutorial as well as other Optimism related tutorials in our [optimism-tutorial](https://github.com/ethereum-optimism/optimism-tutorial/tree/main/ecosystem/attestation-station#key-values) repo.
+- [General atst tutorial](https://github.com/ethereum-optimism/optimism-tutorial/tree/main/ecosystem/attestation-station).
+- [React atst starter](https://github.com/ethereum-optimism/optimism-starter). 
+

packages/atst/package.json

@@ -59,5 +59,15 @@
     "@wagmi/core": "^0.9.2",
     "@wagmi/cli": "~0.1.5",
     "wagmi": "~0.11.0"
-  }
+  },
+  "keywords": [
+    "react",
+    "hooks",
+    "eth",
+    "ethereum",
+    "dapps",
+    "web3",
+    "optimism",
+    "attestation"
+  ]
 }

packages/contracts-bedrock/.gitignore

@@ -11,3 +11,4 @@ tmp-artifacts
 deployments/mainnet-forked
 deploy-config/mainnet-forked.json
 test-case-generator/fuzz
+.resource-metering.csv

packages/contracts-bedrock/contracts/L1/ResourceMetering.sol

@@ -29,13 +29,14 @@ abstract contract ResourceMetering is Initializable {
 
     /**
      * @notice Maximum amount of the resource that can be used within this block.
+     *         This value cannot be larger than the L2 block gas limit.
      */
-    int256 public constant MAX_RESOURCE_LIMIT = 8_000_000;
+    int256 public constant MAX_RESOURCE_LIMIT = 20_000_000;
 
     /**
      * @notice Along with the resource limit, determines the target resource limit.
      */
-    int256 public constant ELASTICITY_MULTIPLIER = 4;
+    int256 public constant ELASTICITY_MULTIPLIER = 10;
 
     /**
      * @notice Target amount of the resource that should be used within this block.
@@ -50,17 +51,21 @@ abstract contract ResourceMetering is Initializable {
     /**
      * @notice Minimum base fee value, cannot go lower than this.
      */
-    int256 public constant MINIMUM_BASE_FEE = 10_000;
+    int256 public constant MINIMUM_BASE_FEE = 1 gwei;
 
     /**
      * @notice Maximum base fee value, cannot go higher than this.
+     *         It is possible for the MAXIMUM_BASE_FEE to raise to a value
+     *         that is so large it will consume the entire gas limit of
+     *         an L1 block.
      */
     int256 public constant MAXIMUM_BASE_FEE = int256(uint256(type(uint128).max));
 
     /**
-     * @notice Initial base fee value.
+     * @notice Initial base fee value. This value must be smaller than the
+     *         MAXIMUM_BASE_FEE.
      */
-    uint128 public constant INITIAL_BASE_FEE = 1_000_000_000;
+    uint128 public constant INITIAL_BASE_FEE = 1 gwei;
 
     /**
      * @notice EIP-1559 style gas parameters.
@@ -84,6 +89,17 @@ abstract contract ResourceMetering is Initializable {
         // Run the underlying function.
         _;
 
+        // Run the metering function.
+        _metered(_amount, initialGas);
+    }
+
+    /**
+     * @notice An internal function that holds all of the logic for metering a resource.
+     *
+     * @param _amount     Amount of the resource requested.
+     * @param _initialGas The amount of gas before any modifier execution.
+     */
+    function _metered(uint64 _amount, uint256 _initialGas) internal {
         // Update block number and base fee if necessary.
         uint256 blockDiff = block.number - params.prevBlockNum;
         if (blockDiff > 0) {
@@ -134,7 +150,7 @@ abstract contract ResourceMetering is Initializable {
         );
 
         // Determine the amount of ETH to be paid.
-        uint256 resourceCost = _amount * params.prevBaseFee;
+        uint256 resourceCost = uint256(_amount) * uint256(params.prevBaseFee);
 
         // We currently charge for this ETH amount as an L1 gas burn, so we convert the ETH amount
         // into gas by dividing by the L1 base fee. We assume a minimum base fee of 1 gwei to avoid
@@ -146,7 +162,7 @@ abstract contract ResourceMetering is Initializable {
         // Give the user a refund based on the amount of gas they used to do all of the work up to
         // this point. Since we're at the end of the modifier, this should be pretty accurate. Acts
         // effectively like a dynamic stipend (with a minimum value).
-        uint256 usedGas = initialGas - gasleft();
+        uint256 usedGas = _initialGas - gasleft();
         if (gasCost > usedGas) {
             Burn.gas(gasCost - usedGas);
         }

packages/contracts-bedrock/contracts/test/BenchmarkTest.t.sol

@@ -32,7 +32,7 @@ contract SetPrevBaseFee_Test is Portal_Initializer {
 // In order to achieve this we make no assertions, and handle everything else in the setUp()
 // function.
 contract GasBenchMark_OptimismPortal is Portal_Initializer {
-    uint128 INITIAL_BASE_FEE;
+    uint128 internal INITIAL_BASE_FEE;
 
     // Reusable default values for a test withdrawal
     Types.WithdrawalTransaction _defaultTx;
@@ -124,7 +124,7 @@ contract GasBenchMark_OptimismPortal is Portal_Initializer {
 }
 
 contract GasBenchMark_L1CrossDomainMessenger is Messenger_Initializer {
-    uint128 INITIAL_BASE_FEE;
+    uint128 internal INITIAL_BASE_FEE;
 
     function setUp() public virtual override {
         super.setUp();
@@ -153,7 +153,7 @@ contract GasBenchMark_L1CrossDomainMessenger is Messenger_Initializer {
 }
 
 contract GasBenchMark_L1StandardBridge_Deposit is Bridge_Initializer {
-    uint128 INITIAL_BASE_FEE;
+    uint128 internal INITIAL_BASE_FEE;
 
     function setUp() public virtual override {
         super.setUp();

packages/contracts-bedrock/foundry.toml

@@ -19,6 +19,9 @@ ffi = true
 fuzz_runs = 16
 no_match_contract = 'EchidnaFuzz'
 
+fs_permissions = [
+  { 'access'='read-write', 'path'='./.resource-metering.csv' },
+]
 
 [profile.ci]
 fuzz_runs = 512

packages/contracts-bedrock/package.json

@@ -28,7 +28,7 @@
     "test": "yarn build:differential && yarn build:fuzz && forge test",
     "coverage": "yarn build:differential && yarn build:fuzz && forge coverage",
     "coverage:lcov": "yarn build:differential && yarn build:fuzz && forge coverage --report lcov",
-    "gas-snapshot": "yarn build:differential && yarn build:fuzz && forge snapshot --no-match-test 'testDiff|testFuzz|invariant'",
+    "gas-snapshot": "yarn build:differential && yarn build:fuzz && forge snapshot --no-match-test 'testDiff|testFuzz|invariant|generateArtifact'",
     "storage-snapshot": "./scripts/storage-snapshot.sh",
     "validate-spacers": "hardhat compile && hardhat validate-spacers",
     "slither": "./scripts/slither.sh",