refactor: remove errors directive comparison

cannon/mipsevm/memory.go

@@ -3,6 +3,7 @@ package mipsevm
 import (
  "encoding/binary"
  "encoding/json"
+ "errors"
  "fmt"
  "io"
  "math/bits"
@@ -278,7 +279,7 @@ func (m *Memory) SetMemoryRange(addr uint32, r io.Reader) error {
  p.InvalidateFull()
  n, err := r.Read(p.Data[pageAddr:])
  if err != nil {
- if err == io.EOF {
+ if errors.Is(err, io.EOF) {
  return nil
  }
  return err

cannon/mipsevm/page.go

@@ -6,6 +6,7 @@ import (
  "encoding/base64"
  "encoding/hex"
  "encoding/json"
+ "errors"
  "fmt"
  "io"
  "sync"
@@ -47,7 +48,7 @@ func (p *Page) UnmarshalJSON(dat []byte) error {
  defer r.Close()
  if n, err := r.Read(p[:]); n != PageSize {
  return fmt.Errorf("epxeted %d bytes, but got %d", PageSize, n)
- } else if err == io.EOF {
+ } else if errors.Is(err, io.EOF) {
  return nil
  } else {
  return err

op-batcher/batcher/channel_builder.go

@@ -300,7 +300,7 @@ func (c *ChannelBuilder) outputReadyFrames() error {
  // When creating a frame from the ready compression data, the frame overhead
  // will be added to the total output size, so we can add it in the condition.
  for c.co.ReadyBytes()+derive.FrameV0OverHeadSize >= int(c.cfg.MaxFrameSize) {
- if err := c.outputFrame(); err == io.EOF {
+ if err := c.outputFrame(); errors.Is(err, io.EOF) {
  return nil
  } else if err != nil {
  return err
@@ -315,7 +315,7 @@ func (c *ChannelBuilder) closeAndOutputAllFrames() error {
  }
 
  for {
- if err := c.outputFrame(); err == io.EOF {
+ if err := c.outputFrame(); errors.Is(err, io.EOF) {
  return nil
  } else if err != nil {
  return err
@@ -329,7 +329,7 @@ func (c *ChannelBuilder) closeAndOutputAllFrames() error {
 func (c *ChannelBuilder) outputFrame() error {
  var buf bytes.Buffer
  fn, err := c.co.OutputFrame(&buf, c.cfg.MaxFrameSize)
- if err != io.EOF && err != nil {
+ if !errors.Is(err, io.EOF) && err != nil {
  return fmt.Errorf("writing frame[%d]: %w", fn, err)
  }
 

op-batcher/batcher/channel_manager_test.go

@@ -1,6 +1,7 @@
 package batcher
 
 import (
+ "errors"
  "io"
  "math/big"
  "math/rand"
@@ -409,7 +410,7 @@ func ChannelManagerCloseAllTxsFailed(t *testing.T, batchType uint) {
  drainTxData := func() (txdatas []txData) {
  for {
  txdata, err := m.TxData(eth.BlockID{})
- if err == io.EOF {
+ if errors.Is(err, io.EOF) {
  return
  }
  require.NoError(err, "Expected channel manager to produce valid tx data")

op-batcher/batcher/driver.go

@@ -376,7 +376,7 @@ func (l *BatchSubmitter) publishStateToL1(queue *txmgr.Queue[txID], receiptsCh c
  }
  err := l.publishTxToL1(l.killCtx, queue, receiptsCh)
  if err != nil {
- if err != io.EOF {
+ if !errors.Is(err, io.EOF) {
  l.Log.Error("error publishing tx to l1", "err", err)
  }
  return
@@ -436,7 +436,7 @@ func (l *BatchSubmitter) publishTxToL1(ctx context.Context, queue *txmgr.Queue[t
  // Collect next transaction data
  txdata, err := l.state.TxData(l1tip.ID())
 
- if err == io.EOF {
+ if errors.Is(err, io.EOF) {
  l.Log.Trace("no transaction data available")
  return err
  } else if err != nil {

op-chain-ops/cmd/receipt-reference-builder/pull.go

@@ -335,7 +335,7 @@ func batchBlockByNumber(ctx context.Context, c *ethclient.Client, blockNumbers [
  int(MaxBatchSize),
  )
  for {
- if err := batchReq.Fetch(ctx); err == io.EOF {
+ if err := batchReq.Fetch(ctx); errors.Is(err, io.EOF) {
  break
  } else if err != nil {
  log.Warn("Failed to Fetch Blocks", "Err", err, "Start", blockNumbers[0], "End", blockNumbers[len(blockNumbers)-1])

op-e2e/actions/l2_batcher.go

@@ -5,6 +5,7 @@ import (
  "context"
  "crypto/ecdsa"
  "crypto/rand"
+ "errors"
  "io"
  "math/big"
 
@@ -239,7 +240,7 @@ func (s *L2Batcher) ActL2BatchSubmit(t Testing, txOpts ...func(tx *types.Dynamic
  data := new(bytes.Buffer)
  data.WriteByte(derive.DerivationVersion0)
  // subtract one, to account for the version byte
- if _, err := s.l2ChannelOut.OutputFrame(data, s.l2BatcherCfg.MaxL1TxSize-1); err == io.EOF {
+ if _, err := s.l2ChannelOut.OutputFrame(data, s.l2BatcherCfg.MaxL1TxSize-1); errors.Is(err, io.EOF) {
  s.l2ChannelOut = nil
  s.l2Submitting = false
  } else if err != nil {
@@ -342,7 +343,7 @@ func (s *L2Batcher) ActL2BatchSubmitMultiBlob(t Testing, numBlobs int) {
  // subtract one, to account for the version byte
  l = s.l2BatcherCfg.MaxL1TxSize - 1
  }
- if _, err := s.l2ChannelOut.OutputFrame(data, l); err == io.EOF {
+ if _, err := s.l2ChannelOut.OutputFrame(data, l); errors.Is(err, io.EOF) {
  s.l2Submitting = false
  if i < numBlobs-1 {
  t.Fatalf("failed to fill up %d blobs, only filled %d", numBlobs, i+1)
@@ -410,7 +411,7 @@ func (s *L2Batcher) ActL2BatchSubmitGarbage(t Testing, kind GarbageKind) {
  data.WriteByte(derive.DerivationVersion0)
 
  // subtract one, to account for the version byte
- if _, err := s.l2ChannelOut.OutputFrame(data, s.l2BatcherCfg.MaxL1TxSize-1); err == io.EOF {
+ if _, err := s.l2ChannelOut.OutputFrame(data, s.l2BatcherCfg.MaxL1TxSize-1); errors.Is(err, io.EOF) {
  s.l2ChannelOut = nil
  s.l2Submitting = false
  } else if err != nil {

op-e2e/actions/l2_verifier.go

@@ -226,7 +226,7 @@ func (s *L2Verifier) ActL2PipelineStep(t Testing) {
 
  s.l2PipelineIdle = false
  err := s.derivation.Step(t.Ctx())
- if err == io.EOF || (err != nil && errors.Is(err, derive.EngineELSyncing)) {
+ if errors.Is(err, io.EOF) || (err != nil && errors.Is(err, derive.EngineELSyncing)) {
  s.l2PipelineIdle = true
  return
  } else if err != nil && errors.Is(err, derive.NotEnoughData) {

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

@@ -2,6 +2,7 @@ package reassemble
 
 import (
  "encoding/json"
+ "errors"
  "fmt"
  "io"
  "log"
@@ -113,7 +114,7 @@ func processFrames(cfg Config, rollupCfg *rollup.Config, id derive.ChannelID, fr
  if ch.IsReady() {
  br, err := derive.BatchReader(ch.Reader(), spec.MaxRLPBytesPerChannel(ch.HighestBlock().Time))
  if err == nil {
- for batchData, err := br(); err != io.EOF; batchData, err = br() {
+ for batchData, err := br(); !errors.Is(err, io.EOF); batchData, err = br() {
  if err != nil {
  fmt.Printf("Error reading batchData for channel %v. Err: %v\n", id.String(), err)
  invalidBatches = true

op-node/p2p/store/ip_ban_book.go

@@ -3,6 +3,7 @@ package store
 import (
  "context"
  "encoding/json"
+ "errors"
  "net"
  "time"
 
@@ -71,7 +72,7 @@ func (d *ipBanBook) startGC() {
 
 func (d *ipBanBook) GetIPBanExpiration(ip net.IP) (time.Time, error) {
  rec, err := d.book.getRecord(ip.To16().String())
- if err == UnknownRecordErr {
+ if errors.Is(err, UnknownRecordErr) {
  return time.Time{}, UnknownBanErr
  }
  if err != nil {

op-node/p2p/store/mdbook.go

@@ -3,6 +3,7 @@ package store
 import (
  "context"
  "encoding/json"
+ "errors"
  "sync/atomic"
  "time"
 
@@ -69,7 +70,7 @@ func (m *metadataBook) startGC() {
 func (m *metadataBook) GetPeerMetadata(id peer.ID) (PeerMetadata, error) {
  record, err := m.book.getRecord(id)
  // If the record is not found, return an empty PeerMetadata
- if err == UnknownRecordErr {
+ if errors.Is(err, UnknownRecordErr) {
  return PeerMetadata{}, nil
  }
  if err != nil {

op-node/p2p/store/peer_ban_book.go

@@ -3,6 +3,7 @@ package store
 import (
  "context"
  "encoding/json"
+ "errors"
  "time"
 
  "github.com/ethereum-optimism/optimism/op-service/clock"
@@ -67,7 +68,7 @@ func (d *peerBanBook) startGC() {
 
 func (d *peerBanBook) GetPeerBanExpiration(id peer.ID) (time.Time, error) {
  rec, err := d.book.getRecord(id)
- if err == UnknownRecordErr {
+ if errors.Is(err, UnknownRecordErr) {
  return time.Time{}, UnknownBanErr
  }
  if err != nil {

op-node/p2p/store/records_book.go

@@ -128,7 +128,7 @@ func (d *recordsBook[K, V]) SetRecord(key K, diff recordDiff[V]) (V, error) {
  d.Lock()
  defer d.Unlock()
  rec, err := d.getRecord(key)
- if err == UnknownRecordErr { // instantiate new record if it does not exist yet
+ if errors.Is(err, UnknownRecordErr) { // instantiate new record if it does not exist yet
  rec = d.newRecord()
  } else if err != nil {
  return d.newRecord(), err

op-node/p2p/store/scorebook.go

@@ -2,6 +2,7 @@ package store
 
 import (
  "context"
+ "errors"
  "sync/atomic"
  "time"
 
@@ -71,7 +72,7 @@ func (d *scoreBook) startGC() {
 
 func (d *scoreBook) GetPeerScores(id peer.ID) (PeerScores, error) {
  record, err := d.book.getRecord(id)
- if err == UnknownRecordErr {
+ if errors.Is(err, UnknownRecordErr) {
  return PeerScores{}, nil // return zeroed scores by default
  }
  if err != nil {

op-node/rollup/derive/batch_queue.go

@@ -148,7 +148,7 @@ func (bq *BatchQueue) NextBatch(ctx context.Context, parent eth.L2BlockRef) (*Si
 
  // Load more data into the batch queue
  outOfData := false
- if batch, err := bq.prev.NextBatch(ctx); err == io.EOF {
+ if batch, err := bq.prev.NextBatch(ctx); errors.Is(err, io.EOF) {
  outOfData = true
  } else if err != nil {
  return nil, false, err
@@ -168,9 +168,9 @@ func (bq *BatchQueue) NextBatch(ctx context.Context, parent eth.L2BlockRef) (*Si
 
  // Finally attempt to derive more batches
  batch, err := bq.deriveNextBatch(ctx, outOfData, parent)
- if err == io.EOF && outOfData {
+ if errors.Is(err, io.EOF) && outOfData {
  return nil, false, io.EOF
- } else if err == io.EOF {
+ } else if errors.Is(err, io.EOF) {
  return nil, false, NotEnoughData
  } else if err != nil {
  return nil, false, err

op-node/rollup/derive/channel_bank.go

@@ -2,6 +2,7 @@ package derive
 
 import (
  "context"
+ "errors"
  "io"
  "slices"
 
@@ -180,7 +181,7 @@ func (cb *ChannelBank) tryReadChannelAtIndex(i int) (data []byte, err error) {
 func (cb *ChannelBank) NextData(ctx context.Context) ([]byte, error) {
  // Do the read from the channel bank first
  data, err := cb.Read()
- if err == io.EOF {
+ if errors.Is(err, io.EOF) {
  // continue - We will attempt to load data into the channel bank
  } else if err != nil {
  return nil, err
@@ -189,7 +190,7 @@ func (cb *ChannelBank) NextData(ctx context.Context) ([]byte, error) {
  }
 
  // Then load data into the channel bank
- if frame, err := cb.prev.NextFrame(ctx); err == io.EOF {
+ if frame, err := cb.prev.NextFrame(ctx); errors.Is(err, io.EOF) {
  return nil, io.EOF
  } else if err != nil {
  return nil, err

op-node/rollup/derive/channel_in_reader.go

@@ -3,6 +3,7 @@ package derive
 import (
  "bytes"
  "context"
+ "errors"
  "fmt"
  "io"
 
@@ -65,7 +66,7 @@ func (cr *ChannelInReader) NextChannel() {
 // It will return a temporary error if it needs to be called again to advance some internal state.
 func (cr *ChannelInReader) NextBatch(ctx context.Context) (Batch, error) {
  if cr.nextBatchFn == nil {
- if data, err := cr.prev.NextData(ctx); err == io.EOF {
+ if data, err := cr.prev.NextData(ctx); errors.Is(err, io.EOF) {
  return nil, io.EOF
  } else if err != nil {
  return nil, err
@@ -79,7 +80,7 @@ func (cr *ChannelInReader) NextBatch(ctx context.Context) (Batch, error) {
  // TODO: can batch be non nil while err == io.EOF
  // This depends on the behavior of rlp.Stream
  batchData, err := cr.nextBatchFn()
- if err == io.EOF {
+ if errors.Is(err, io.EOF) {
  cr.NextChannel()
  return nil, NotEnoughData
  } else if err != nil {

op-node/rollup/derive/engine_queue.go

@@ -304,7 +304,7 @@ func (eq *EngineQueue) Step(ctx context.Context) error {
  // Trying unsafe payload should be done before safe attributes
  // It allows the unsafe head can move forward while the long-range consolidation is in progress.
  if eq.unsafePayloads.Len() > 0 {
- if err := eq.tryNextUnsafePayload(ctx); err != io.EOF {
+ if err := eq.tryNextUnsafePayload(ctx); !errors.Is(err, io.EOF) {
  return err
  }
  // EOF error means we can't process the next unsafe payload. Then we should process next safe attributes.
@@ -331,7 +331,7 @@ func (eq *EngineQueue) Step(ctx context.Context) error {
  if err := eq.tryFinalizePastL2Blocks(ctx); err != nil {
  return err
  }
- if next, err := eq.prev.NextAttributes(ctx, eq.ec.PendingSafeL2Head()); err == io.EOF {
+ if next, err := eq.prev.NextAttributes(ctx, eq.ec.PendingSafeL2Head()); errors.Is(err, io.EOF) {
  return io.EOF
  } else if err != nil {
  return err

op-node/rollup/derive/l1_retrieval.go

@@ -2,6 +2,7 @@ package derive
 
 import (
  "context"
+ "errors"
  "fmt"
  "io"
 
@@ -49,7 +50,7 @@ func (l1r *L1Retrieval) Origin() eth.L1BlockRef {
 func (l1r *L1Retrieval) NextData(ctx context.Context) ([]byte, error) {
  if l1r.datas == nil {
  next, err := l1r.prev.NextL1Block(ctx)
- if err == io.EOF {
+ if errors.Is(err, io.EOF) {
  return nil, io.EOF
  } else if err != nil {
  return nil, err
@@ -61,7 +62,7 @@ func (l1r *L1Retrieval) NextData(ctx context.Context) ([]byte, error) {
 
  l1r.log.Debug("fetching next piece of data")
  data, err := l1r.datas.Next(ctx)
- if err == io.EOF {
+ if errors.Is(err, io.EOF) {
  l1r.datas = nil
  return nil, io.EOF
  } else if err != nil {

op-node/rollup/derive/pipeline.go

@@ -162,7 +162,7 @@ func (dp *DerivationPipeline) Step(ctx context.Context) error {
 
  // if any stages need to be reset, do that first.
  if dp.resetting < len(dp.stages) {
- if err := dp.stages[dp.resetting].Reset(ctx, dp.eng.Origin(), dp.eng.SystemConfig()); err == io.EOF {
+ if err := dp.stages[dp.resetting].Reset(ctx, dp.eng.Origin(), dp.eng.SystemConfig()); errors.Is(err, io.EOF) {
  dp.log.Debug("reset of stage completed", "stage", dp.resetting, "origin", dp.eng.Origin())
  dp.resetting += 1
  return nil
@@ -174,7 +174,7 @@ func (dp *DerivationPipeline) Step(ctx context.Context) error {
  }
 
  // Now step the engine queue. It will pull earlier data as needed.
- if err := dp.eng.Step(ctx); err == io.EOF {
+ if err := dp.eng.Step(ctx); errors.Is(err, io.EOF) {
  // If every stage has returned io.EOF, try to advance the L1 Origin
  return dp.traversal.AdvanceL1Block(ctx)
  } else if errors.Is(err, EngineELSyncing) {

op-node/rollup/derive/plasma_data_source_test.go

@@ -2,6 +2,7 @@ package derive
 
 import (
  "context"
+ "errors"
  "io"
  "math/big"
  "math/rand"
@@ -260,7 +261,7 @@ func TestPlasmaDataSource(t *testing.T) {
  break
  }
 
- for data, err := src.Next(ctx); err != io.EOF; data, err = src.Next(ctx) {
+ for data, err := src.Next(ctx); !errors.Is(err, io.EOF); data, err = src.Next(ctx) {
  logger.Info("yielding data")
  // check that each commitment is resolved
  require.NoError(t, err)