Reduce complexity by reducing nesting

arbnode/dataposter/slice_storage.go

@@ -32,11 +32,10 @@ func (s *SliceStorage[Item]) GetContents(ctx context.Context, startingIndex uint
 }
 
 func (s *SliceStorage[Item]) GetLast(ctx context.Context) (*Item, error) {
-	if len(s.queue) > 0 {
-		return s.queue[len(s.queue)-1], nil
-	} else {
+	if len(s.queue) <= 0 {
 		return nil, nil
 	}
+	return s.queue[len(s.queue)-1], nil
 }
 
 func (s *SliceStorage[Item]) Prune(ctx context.Context, keepStartingAt uint64) error {

arbnode/delayed.go

@@ -271,13 +271,14 @@ func (b *DelayedBridge) parseMessage(ctx context.Context, ethLog types.Log) (*bi
 		}
 		b.messageProviders[ethLog.Address] = con
 	}
-	if ethLog.Topics[0] == inboxMessageDeliveredID {
+	switch {
+	case ethLog.Topics[0] == inboxMessageDeliveredID:
 		parsedLog, err := con.ParseInboxMessageDelivered(ethLog)
 		if err != nil {
 			return nil, nil, errors.WithStack(err)
 		}
 		return parsedLog.MessageNum, parsedLog.Data, nil
-	} else if ethLog.Topics[0] == inboxMessageFromOriginID {
+	case ethLog.Topics[0] == inboxMessageFromOriginID:
 		parsedLog, err := con.ParseInboxMessageDeliveredFromOrigin(ethLog)
 		if err != nil {
 			return nil, nil, errors.WithStack(err)
@@ -292,7 +293,7 @@ func (b *DelayedBridge) parseMessage(ctx context.Context, ethLog types.Log) (*bi
 			return nil, nil, errors.WithStack(err)
 		}
 		return parsedLog.MessageNum, args["messageData"].([]byte), nil
-	} else {
+	default:
 		return nil, nil, errors.New("unexpected log type")
 	}
 }

arbnode/execution/sequencer.go

@@ -184,9 +184,8 @@ func (c *nonceCache) matches(header *types.Header) bool {
 		// The header is updated as the block is built,
 		// so instead of checking its hash, we do a pointer comparison.
 		return c.dirty == header
-	} else {
-		return c.block == header.ParentHash
 	}
+	return c.block == header.ParentHash
 }
 
 func (c *nonceCache) Reset(block common.Hash) {
@@ -982,10 +981,9 @@ func (s *Sequencer) Start(ctxIn context.Context) error {
 		if madeBlock {
 			// Note: this may return a negative duration, but timers are fine with that (they treat negative durations as 0).
 			return time.Until(nextBlock)
-		} else {
-			// If we didn't make a block, try again immediately.
-			return 0
 		}
+		// If we didn't make a block, try again immediately.
+		return 0
 	})
 
 	return nil

arbnode/execution/tx_pre_checker.go

@@ -79,35 +79,34 @@ type NonceError struct {
 func (e NonceError) Error() string {
 	if e.txNonce < e.stateNonce {
 		return fmt.Sprintf("%v: address %v, tx: %d state: %d", core.ErrNonceTooLow, e.sender, e.txNonce, e.stateNonce)
-	} else if e.txNonce > e.stateNonce {
+	}
+	if e.txNonce > e.stateNonce {
 		return fmt.Sprintf("%v: address %v, tx: %d state: %d", core.ErrNonceTooHigh, e.sender, e.txNonce, e.stateNonce)
-	} else {
-		// This should be unreachable
-		return fmt.Sprintf("invalid nonce error for address %v nonce %v", e.sender, e.txNonce)
 	}
+	// This should be unreachable
+	return fmt.Sprintf("invalid nonce error for address %v nonce %v", e.sender, e.txNonce)
 }
 
 func (e NonceError) Unwrap() error {
 	if e.txNonce < e.stateNonce {
 		return core.ErrNonceTooLow
-	} else if e.txNonce > e.stateNonce {
+	}
+	if e.txNonce > e.stateNonce {
 		return core.ErrNonceTooHigh
-	} else {
-		// This should be unreachable
-		return nil
 	}
+	// This should be unreachable
+	return nil
 }
 
 func MakeNonceError(sender common.Address, txNonce uint64, stateNonce uint64) error {
-	if txNonce != stateNonce {
-		return NonceError{
-			sender:     sender,
-			txNonce:    txNonce,
-			stateNonce: stateNonce,
-		}
-	} else {
+	if txNonce == stateNonce {
 		return nil
 	}
+	return NonceError{
+		sender:     sender,
+		txNonce:    txNonce,
+		stateNonce: stateNonce,
+	}
 }
 
 func PreCheckTx(bc *core.BlockChain, chainConfig *params.ChainConfig, header *types.Header, statedb *state.StateDB, arbos *arbosState.ArbosState, tx *types.Transaction, options *arbitrum_types.ConditionalOptions, config *TxPreCheckerConfig) error {

arbnode/inbox_reader.go

@@ -398,9 +398,8 @@ func (r *InboxReader) run(ctx context.Context, hadError bool) error {
 					idx := int(batchNum - sequencerBatches[0].SequenceNumber)
 					if idx < len(sequencerBatches) {
 						return sequencerBatches[idx].Serialize(ctx, r.l1Reader.Client())
-					} else {
-						log.Warn("missing mentioned batch in L1 message lookup", "batch", batchNum)
 					}
+					log.Warn("missing mentioned batch in L1 message lookup", "batch", batchNum)
 				}
 				return r.GetSequencerMessageBytes(ctx, batchNum)
 			})

arbnode/inbox_tracker.go

@@ -334,9 +334,8 @@ func (t *InboxTracker) AddDelayedMessages(messages []*DelayedInboxMessage, hardR
 		if err != nil {
 			if errors.Is(err, AccumulatorNotFoundErr) {
 				return errors.New("missing previous delayed message")
-			} else {
-				return err
 			}
+			return err
 		}
 	}
 
@@ -422,15 +421,13 @@ func (t *InboxTracker) setDelayedCountReorgAndWriteBatch(batch ethdb.Batch, newD
 	var reorgSeqBatchesToCount *uint64
 	for seqBatchIter.Next() {
 		var batchSeqNum uint64
-		err := rlp.DecodeBytes(seqBatchIter.Value(), &batchSeqNum)
-		if err != nil {
+		if err := rlp.DecodeBytes(seqBatchIter.Value(), &batchSeqNum); err != nil {
 			return err
 		}
 		if !canReorgBatches {
 			return fmt.Errorf("reorging of sequencer batch number %v via delayed messages reorg to count %v disabled in this instance", batchSeqNum, newDelayedCount)
 		}
-		err = batch.Delete(seqBatchIter.Key())
-		if err != nil {
+		if err := batch.Delete(seqBatchIter.Key()); err != nil {
 			return err
 		}
 		if reorgSeqBatchesToCount == nil {
@@ -440,47 +437,44 @@ func (t *InboxTracker) setDelayedCountReorgAndWriteBatch(batch ethdb.Batch, newD
 			reorgSeqBatchesToCount = &batchSeqNum
 		}
 	}
-	err = seqBatchIter.Error()
-	if err != nil {
+	if err := seqBatchIter.Error(); err != nil {
 		return err
 	}
 	// Release the iterator early.
 	// It's fine to call Release multiple times,
 	// which we'll do because of the defer.
 	seqBatchIter.Release()
-	if reorgSeqBatchesToCount != nil {
-		// Clear the batchMeta cache after writing the reorg to disk
-		defer t.clearBatchMetaCache()
+	if reorgSeqBatchesToCount == nil {
+		return batch.Write()
+	}
+	// Clear the batchMeta cache after writing the reorg to disk
+	defer t.clearBatchMetaCache()
 
-		count := *reorgSeqBatchesToCount
-		if t.validator != nil {
-			t.validator.ReorgToBatchCount(count)
-		}
-		countData, err := rlp.EncodeToBytes(count)
-		if err != nil {
-			return err
-		}
-		err = batch.Put(sequencerBatchCountKey, countData)
-		if err != nil {
-			return err
-		}
-		log.Warn("InboxTracker delayed message reorg is causing a sequencer batch reorg", "sequencerBatchCount", count, "delayedCount", newDelayedCount)
-		err = deleteStartingAt(t.db, batch, sequencerBatchMetaPrefix, uint64ToKey(count))
+	count := *reorgSeqBatchesToCount
+	if t.validator != nil {
+		t.validator.ReorgToBatchCount(count)
+	}
+	countData, err = rlp.EncodeToBytes(count)
+	if err != nil {
+		return err
+	}
+	if err := batch.Put(sequencerBatchCountKey, countData); err != nil {
+		return err
+	}
+	log.Warn("InboxTracker delayed message reorg is causing a sequencer batch reorg", "sequencerBatchCount", count, "delayedCount", newDelayedCount)
+
+	if err := deleteStartingAt(t.db, batch, sequencerBatchMetaPrefix, uint64ToKey(count)); err != nil {
+		return err
+	}
+	var prevMesssageCount arbutil.MessageIndex
+	if count > 0 {
+		prevMesssageCount, err = t.GetBatchMessageCount(count - 1)
 		if err != nil {
 			return err
 		}
-		var prevMesssageCount arbutil.MessageIndex
-		if count > 0 {
-			prevMesssageCount, err = t.GetBatchMessageCount(count - 1)
-			if err != nil {
-				return err
-			}
-		}
-		// Writes batch
-		return t.txStreamer.ReorgToAndEndBatch(batch, prevMesssageCount)
-	} else {
-		return batch.Write()
 	}
+	// Writes batch
+	return t.txStreamer.ReorgToAndEndBatch(batch, prevMesssageCount)
 }
 
 type multiplexerBackend struct {
@@ -569,9 +563,11 @@ func (t *InboxTracker) AddSequencerBatches(ctx context.Context, client arbutil.L
 			if errors.Is(err, AccumulatorNotFoundErr) {
 				// We somehow missed a referenced delayed message; go back and look for it
 				return delayedMessagesMismatch
-			} else if err != nil {
+			}
+			if err != nil {
 				return err
-			} else if haveDelayedAcc != batch.AfterDelayedAcc {
+			}
+			if haveDelayedAcc != batch.AfterDelayedAcc {
 				// We somehow missed a delayed message reorg; go back and look for it
 				return delayedMessagesMismatch
 			}
@@ -705,7 +701,8 @@ func (t *InboxTracker) AddSequencerBatches(ctx context.Context, client arbutil.L
 		prevprevbatchmeta, err := t.GetBatchMetadata(pos - 2)
 		if errors.Is(err, AccumulatorNotFoundErr) {
 			return errors.New("missing previous previous sequencer batch")
-		} else if err != nil {
+		}
+		if err != nil {
 			return err
 		}
 		if prevprevbatchmeta.MessageCount > 0 {
@@ -727,7 +724,8 @@ func (t *InboxTracker) ReorgDelayedTo(count uint64, canReorgBatches bool) error
 	}
 	if currentCount == count {
 		return nil
-	} else if currentCount < count {
+	}
+	if currentCount < count {
 		return errors.New("attempted to reorg to future delayed count")
 	}
 
@@ -744,7 +742,8 @@ func (t *InboxTracker) ReorgBatchesTo(count uint64) error {
 		prevBatchMeta, err = t.GetBatchMetadata(count - 1)
 		if errors.Is(err, AccumulatorNotFoundErr) {
 			return errors.New("attempted to reorg to future batch count")
-		} else if err != nil {
+		}
+		if err != nil {
 			return err
 		}
 	}

arbnode/node.go

@@ -784,9 +784,8 @@ func createNodeImpl(
 	if err != nil {
 		if config.ValidatorRequired() || config.Staker.Enable {
 			return nil, fmt.Errorf("%w: failed to init block validator", err)
-		} else {
-			log.Warn("validation not supported", "err", err)
 		}
+		log.Warn("validation not supported", "err", err)
 		statelessBlockValidator = nil
 	}
 
@@ -1051,9 +1050,8 @@ func (n *Node) Start(ctx context.Context) error {
 		if err != nil {
 			if n.configFetcher.Get().ValidatorRequired() {
 				return fmt.Errorf("error initializing stateless block validator: %w", err)
-			} else {
-				log.Info("validation not set up", "err", err)
 			}
+			log.Info("validation not set up", "err", err)
 			n.StatelessBlockValidator = nil
 			n.BlockValidator = nil
 		}

arbnode/transaction_streamer.go

@@ -556,45 +556,43 @@ func (s *TransactionStreamer) countDuplicateMessages(
 		if !bytes.Equal(haveMessage, wantMessage) {
 			// Current message does not exactly match message in database
 			var dbMessageParsed arbostypes.MessageWithMetadata
-			err := rlp.DecodeBytes(haveMessage, &dbMessageParsed)
-			if err != nil {
+
+			if err := rlp.DecodeBytes(haveMessage, &dbMessageParsed); err != nil {
 				log.Warn("TransactionStreamer: Reorg detected! (failed parsing db message)",
 					"pos", pos,
 					"err", err,
 				)
 				return curMsg, true, nil, nil
-			} else {
-				var duplicateMessage bool
-				if nextMessage.Message != nil {
-					if dbMessageParsed.Message.BatchGasCost == nil || nextMessage.Message.BatchGasCost == nil {
-						// Remove both of the batch gas costs and see if the messages still differ
-						nextMessageCopy := nextMessage
-						nextMessageCopy.Message = new(arbostypes.L1IncomingMessage)
-						*nextMessageCopy.Message = *nextMessage.Message
-						batchGasCostBkup := dbMessageParsed.Message.BatchGasCost
-						dbMessageParsed.Message.BatchGasCost = nil
-						nextMessageCopy.Message.BatchGasCost = nil
-						if reflect.DeepEqual(dbMessageParsed, nextMessageCopy) {
-							// Actually this isn't a reorg; only the batch gas costs differed
-							duplicateMessage = true
-							// If possible - update the message in the database to add the gas cost cache.
-							if batch != nil && nextMessage.Message.BatchGasCost != nil {
-								if *batch == nil {
-									*batch = s.db.NewBatch()
-								}
-								err = s.writeMessage(pos, nextMessage, *batch)
-								if err != nil {
-									return 0, false, nil, err
-								}
+			}
+			var duplicateMessage bool
+			if nextMessage.Message != nil {
+				if dbMessageParsed.Message.BatchGasCost == nil || nextMessage.Message.BatchGasCost == nil {
+					// Remove both of the batch gas costs and see if the messages still differ
+					nextMessageCopy := nextMessage
+					nextMessageCopy.Message = new(arbostypes.L1IncomingMessage)
+					*nextMessageCopy.Message = *nextMessage.Message
+					batchGasCostBkup := dbMessageParsed.Message.BatchGasCost
+					dbMessageParsed.Message.BatchGasCost = nil
+					nextMessageCopy.Message.BatchGasCost = nil
+					if reflect.DeepEqual(dbMessageParsed, nextMessageCopy) {
+						// Actually this isn't a reorg; only the batch gas costs differed
+						duplicateMessage = true
+						// If possible - update the message in the database to add the gas cost cache.
+						if batch != nil && nextMessage.Message.BatchGasCost != nil {
+							if *batch == nil {
+								*batch = s.db.NewBatch()
+							}
+							if err := s.writeMessage(pos, nextMessage, *batch); err != nil {
+								return 0, false, nil, err
 							}
 						}
-						dbMessageParsed.Message.BatchGasCost = batchGasCostBkup
 					}
+					dbMessageParsed.Message.BatchGasCost = batchGasCostBkup
 				}
+			}
 
-				if !duplicateMessage {
-					return curMsg, true, &dbMessageParsed, nil
-				}
+			if !duplicateMessage {
+				return curMsg, true, &dbMessageParsed, nil
 			}
 		}