fix lint errors

cmd/lotus-chainwatch/processor/power.go

@@ -88,30 +88,24 @@ func (p *Processor) processPowerActors(ctx context.Context, powerTips ActorTips)
 				return nil, xerrors.Errorf("get power state (@ %s): %w", pw.common.stateroot.String(), err)
 			}
 
-			if totalPower, err := powerActorState.TotalPower(); err != nil {
+			totalPower, err := powerActorState.TotalPower()
+			if err != nil {
 				return nil, xerrors.Errorf("failed to compute total power: %w", err)
-			} else {
-				pw.totalRawBytes = totalPower.RawBytePower
-				pw.totalQualityAdjustedBytes = totalPower.QualityAdjPower
 			}
 
-			if totalCommitted, err := powerActorState.TotalCommitted(); err != nil {
+			totalCommitted, err := powerActorState.TotalCommitted()
+			if err != nil {
 				return nil, xerrors.Errorf("failed to compute total committed: %w", err)
-			} else {
-				pw.totalRawBytesCommitted = totalCommitted.RawBytePower
-				pw.totalQualityAdjustedBytesCommitted = totalCommitted.QualityAdjPower
 			}
 
-			if totalLocked, err := powerActorState.TotalLocked(); err != nil {
+			totalLocked, err := powerActorState.TotalLocked()
+			if err != nil {
 				return nil, xerrors.Errorf("failed to compute total locked: %w", err)
-			} else {
-				pw.totalPledgeCollateral = totalLocked
 			}
 
-			if powerSmoothed, err := powerActorState.TotalPowerSmoothed(); err != nil {
+			powerSmoothed, err := powerActorState.TotalPowerSmoothed()
+			if err != nil {
 				return nil, xerrors.Errorf("failed to determine smoothed power: %w", err)
-			} else {
-				pw.qaPowerSmoothed = powerSmoothed
 			}
 
 			// NOTE: this doesn't set new* fields. Previously, we
@@ -120,12 +114,19 @@ func (p *Processor) processPowerActors(ctx context.Context, powerTips ActorTips)
 			// state and don't represent "new" power, as was
 			// assumed.
 
-			if participating, total, err := powerActorState.MinerCounts(); err != nil {
+			participatingMiners, totalMiners, err := powerActorState.MinerCounts()
+			if err != nil {
 				return nil, xerrors.Errorf("failed to count miners: %w", err)
-			} else {
-				pw.minerCountAboveMinimumPower = int64(participating)
-				pw.minerCount = int64(total)
 			}
+
+			pw.totalRawBytes = totalPower.RawBytePower
+			pw.totalQualityAdjustedBytes = totalPower.QualityAdjPower
+			pw.totalRawBytesCommitted = totalCommitted.RawBytePower
+			pw.totalQualityAdjustedBytesCommitted = totalCommitted.QualityAdjPower
+			pw.totalPledgeCollateral = totalLocked
+			pw.qaPowerSmoothed = powerSmoothed
+			pw.minerCountAboveMinimumPower = int64(participatingMiners)
+			pw.minerCount = int64(totalMiners)
 		}
 	}
 

cmd/lotus-chainwatch/processor/reward.go

@@ -6,6 +6,7 @@ import (
 
 	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -21,7 +22,7 @@ type rewardActorInfo struct {
 	cumSumBaselinePower big.Int
 	cumSumRealizedPower big.Int
 
-	effectiveNetworkTime   int64
+	effectiveNetworkTime   abi.ChainEpoch
 	effectiveBaselinePower big.Int
 
 	// NOTE: These variables are wrong. Talk to @ZX about fixing. These _do
@@ -33,53 +34,45 @@ type rewardActorInfo struct {
 	totalMinedReward big.Int
 }
 
-func (rw *rewardActorInfo) set(s reward.State) error {
+func (rw *rewardActorInfo) set(s reward.State) (err error) {
-	if p, err := s.CumsumBaseline(); err != nil {
+	rw.cumSumBaselinePower, err = s.CumsumBaseline()
+	if err != nil {
 		return xerrors.Errorf("getting cumsum baseline power (@ %s): %w", rw.common.stateroot.String(), err)
-	} else {
-		rw.cumSumBaselinePower = p
 	}
 
-	if p, err := s.CumsumRealized(); err != nil {
+	rw.cumSumRealizedPower, err = s.CumsumRealized()
+	if err != nil {
 		return xerrors.Errorf("getting cumsum realized power (@ %s): %w", rw.common.stateroot.String(), err)
-	} else {
-		rw.cumSumRealizedPower = p
 	}
 
-	if t, err := s.EffectiveNetworkTime(); err != nil {
+	rw.effectiveNetworkTime, err = s.EffectiveNetworkTime()
+	if err != nil {
 		return xerrors.Errorf("getting effective network time (@ %s): %w", rw.common.stateroot.String(), err)
-	} else {
-		rw.effectiveNetworkTime = int64(t)
 	}
 
-	if p, err := s.EffectiveBaselinePower(); err != nil {
+	rw.effectiveBaselinePower, err = s.EffectiveBaselinePower()
+	if err != nil {
 		return xerrors.Errorf("getting effective baseline power (@ %s): %w", rw.common.stateroot.String(), err)
-	} else {
-		rw.effectiveBaselinePower = p
 	}
 
-	if t, err := s.TotalStoragePowerReward(); err != nil {
+	rw.totalMinedReward, err = s.TotalStoragePowerReward()
+	if err != nil {
 		return xerrors.Errorf("getting  total mined (@ %s): %w", rw.common.stateroot.String(), err)
-	} else {
-		rw.totalMinedReward = t
 	}
 
-	if p, err := s.ThisEpochBaselinePower(); err != nil {
+	rw.newBaselinePower, err = s.ThisEpochBaselinePower()
+	if err != nil {
 		return xerrors.Errorf("getting this epoch baseline power (@ %s): %w", rw.common.stateroot.String(), err)
-	} else {
-		rw.newBaselinePower = p
 	}
 
-	if t, err := s.ThisEpochReward(); err != nil {
+	rw.newBaseReward, err = s.ThisEpochReward()
+	if err != nil {
 		return xerrors.Errorf("getting this epoch baseline power (@ %s): %w", rw.common.stateroot.String(), err)
-	} else {
-		rw.newBaseReward = t
 	}
 
-	if e, err := s.ThisEpochRewardSmoothed(); err != nil {
+	rw.newSmoothingEstimate, err = s.ThisEpochRewardSmoothed()
+	if err != nil {
 		return xerrors.Errorf("getting this epoch baseline power (@ %s): %w", rw.common.stateroot.String(), err)
-	} else {
-		rw.newSmoothingEstimate = e
 	}
 	return nil
 }
@@ -213,7 +206,7 @@ func (p *Processor) persistRewardActors(ctx context.Context, rewards []rewardAct
 			rewardState.common.stateroot.String(),
 			rewardState.cumSumBaselinePower.String(),
 			rewardState.cumSumRealizedPower.String(),
-			rewardState.effectiveNetworkTime,
+			uint64(rewardState.effectiveNetworkTime),
 			rewardState.effectiveBaselinePower.String(),
 			rewardState.newBaselinePower.String(),
 			rewardState.newBaseReward.String(),