[Draft] PR for v9

rocketpool/api/network/generate-tree.go

@@ -7,6 +7,7 @@ import (
 	"github.com/fatih/color"
 	"github.com/rocket-pool/rocketpool-go/rewards"
 	"github.com/rocket-pool/smartnode/shared/services"
+	"github.com/rocket-pool/smartnode/shared/services/config"
 	"github.com/rocket-pool/smartnode/shared/types/api"
 	"github.com/urfave/cli"
 )
@@ -39,7 +40,7 @@ func canGenerateRewardsTree(c *cli.Context, index uint64) (*api.CanNetworkGenera
 	response.CurrentIndex = currentIndexBig.Uint64()
 
 	// Get the path of the file to save
-	filePath := cfg.Smartnode.GetRewardsTreePath(index, true)
+	filePath := cfg.Smartnode.GetRewardsTreePath(index, true, config.RewardsExtensionJSON)
 	_, err = os.Stat(filePath)
 	if os.IsNotExist(err) {
 		response.TreeFileExists = false

rocketpool/node/collectors/node-collector.go

@@ -321,8 +321,10 @@ func (collector *NodeCollector) Collect(channel chan<- prometheus.Metric) {
 		if !previousInterval.TreeFileExists {
 			return fmt.Errorf("Error retrieving previous interval's total node weight: rewards file %s doesn't exist for interval %d", previousInterval.TreeFilePath, previousRewardIndex)
 		}
-		// Convert to a float, accuracy loss is meaningless compared to the heuristic's natural inaccuracy.
-		previousIntervalTotalNodeWeight = &previousInterval.TotalNodeWeight.Int
+
+		if previousInterval.TotalNodeWeight != nil {
+			previousIntervalTotalNodeWeight.Set(previousInterval.TotalNodeWeight)
+		}
 
 		// Get the info for each claimed interval
 		for _, claimedInterval := range claimed {
@@ -533,6 +535,7 @@ func (collector *NodeCollector) Collect(channel chan<- prometheus.Metric) {
 
 		nodeWeightSum := big.NewInt(0).Add(nodeWeight, previousIntervalTotalNodeWeight)
 
+		// Convert to a float, accuracy loss is meaningless compared to the heuristic's natural inaccuracy.
 		// nodeWeightRatio = current_node_weight / (current_node_weight + previous_interval_total_node_weight)
 		nodeWeightRatio, _ := big.NewFloat(0).Quo(
 			big.NewFloat(0).SetInt(nodeWeight),

rocketpool/node/download-reward-trees.go

@@ -96,7 +96,7 @@ func (d *downloadRewardsTrees) run(state *state.NetworkState) error {
 	missingIntervals := []uint64{}
 	for i := uint64(0); i < currentIndex; i++ {
 		// Check if the tree file exists
-		treeFilePath := d.cfg.Smartnode.GetRewardsTreePath(i, true)
+		treeFilePath := d.cfg.Smartnode.GetRewardsTreePath(i, true, config.RewardsExtensionJSON)
 		_, err = os.Stat(treeFilePath)
 		if os.IsNotExist(err) {
 			d.log.Printlnf("You are missing the rewards tree file for interval %d.", i)

rocketpool/watchtower/generate-rewards-tree.go

@@ -234,53 +234,46 @@ func (t *generateRewardsTree) generateRewardsTree(index uint64) {
 // Implementation for rewards tree generation using a viable EC
 func (t *generateRewardsTree) generateRewardsTreeImpl(rp *rocketpool.RocketPool, index uint64, generationPrefix string, rewardsEvent rewards.RewardsEvent, elBlockHeader *types.Header, state *state.NetworkState) {
 
+	// Determine the end of the interval
+	snapshotEnd := &rprewards.SnapshotEnd{
+		ConsensusBlock: rewardsEvent.ConsensusBlock.Uint64(),
+		ExecutionBlock: rewardsEvent.ExecutionBlock.Uint64(),
+		Slot:           state.BeaconConfig.FirstSlotAtLeast(rewardsEvent.IntervalEndTime.Unix()),
+	}
+
 	// Generate the rewards file
 	start := time.Now()
-	treegen, err := rprewards.NewTreeGenerator(&t.log, generationPrefix, rp, t.cfg, t.bc, index, rewardsEvent.IntervalStartTime, rewardsEvent.IntervalEndTime, rewardsEvent.ConsensusBlock.Uint64(), elBlockHeader, rewardsEvent.IntervalsPassed.Uint64(), state, nil)
+	treegen, err := rprewards.NewTreeGenerator(&t.log, generationPrefix, rp, t.cfg, t.bc, index, rewardsEvent.IntervalStartTime, rewardsEvent.IntervalEndTime, snapshotEnd, elBlockHeader, rewardsEvent.IntervalsPassed.Uint64(), state, nil)
 	if err != nil {
 		t.handleError(fmt.Errorf("%s Error creating Merkle tree generator: %w", generationPrefix, err))
 		return
 	}
-	rewardsFile, err := treegen.GenerateTree()
+	treeResult, err := treegen.GenerateTree()
 	if err != nil {
 		t.handleError(fmt.Errorf("%s Error generating Merkle tree: %w", generationPrefix, err))
 		return
 	}
-	header := rewardsFile.GetHeader()
-	for address, network := range header.InvalidNetworkNodes {
+	rewardsFile := treeResult.RewardsFile
+	for address, network := range treeResult.InvalidNetworkNodes {
 		t.log.Printlnf("%s WARNING: Node %s has invalid network %d assigned! Using 0 (mainnet) instead.", generationPrefix, address.Hex(), network)
 	}
 	t.log.Printlnf("%s Finished in %s", generationPrefix, time.Since(start).String())
 
 	// Validate the Merkle root
-	root := common.BytesToHash(header.MerkleTree.Root())
-	if root != rewardsEvent.MerkleRoot {
-		t.log.Printlnf("%s WARNING: your Merkle tree had a root of %s, but the canonical Merkle tree's root was %s. This file will not be usable for claiming rewards.", generationPrefix, root.Hex(), rewardsEvent.MerkleRoot.Hex())
+	root := rewardsFile.GetMerkleRoot()
+	if root != rewardsEvent.MerkleRoot.Hex() {
+		t.log.Printlnf("%s WARNING: your Merkle tree had a root of %s, but the canonical Merkle tree's root was %s. This file will not be usable for claiming rewards.", generationPrefix, root, rewardsEvent.MerkleRoot.Hex())
 	} else {
-		t.log.Printlnf("%s Your Merkle tree's root of %s matches the canonical root! You will be able to use this file for claiming rewards.", generationPrefix, header.MerkleRoot)
+		t.log.Printlnf("%s Your Merkle tree's root of %s matches the canonical root! You will be able to use this file for claiming rewards.", generationPrefix, root)
 	}
 
-	// Create the JSON files
 	rewardsFile.SetMinipoolPerformanceFileCID("---")
+
+	// Save the files
 	t.log.Printlnf("%s Saving JSON files...", generationPrefix)
-	localMinipoolPerformanceFile := rprewards.NewLocalFile[rprewards.IMinipoolPerformanceFile](
-		rewardsFile.GetMinipoolPerformanceFile(),
-		t.cfg.Smartnode.GetMinipoolPerformancePath(index, true),
-	)
-	localRewardsFile := rprewards.NewLocalFile[rprewards.IRewardsFile](
-		rewardsFile,
-		t.cfg.Smartnode.GetRewardsTreePath(index, true),
-	)
-
-	// Write the files
-	err = localMinipoolPerformanceFile.Write()
-	if err != nil {
-		t.handleError(fmt.Errorf("%s error saving minipool performance file: %w", generationPrefix, err))
-		return
-	}
-	err = localRewardsFile.Write()
+	_, _, err = treegen.SaveFiles(treeResult, false)
 	if err != nil {
-		t.handleError(fmt.Errorf("%s error saving rewards file: %w", generationPrefix, err))
+		t.handleError(fmt.Errorf("%s failed to save rewards artifacts: %w", generationPrefix, err))
 		return
 	}
 

rocketpool/watchtower/submit-network-balances.go

@@ -352,10 +352,16 @@ func (t *submitNetworkBalances) getNetworkBalances(elBlockHeader *types.Header,
 		timeSinceStart := slotTime.Sub(startTime)
 		intervalsPassed := timeSinceStart / intervalTime
 		endTime := slotTime
+		// Since we aren't generating an actual tree, just use beaconBlock as the snapshotEnd
+		snapshotEnd := &rprewards.SnapshotEnd{
+			Slot:           beaconBlock,
+			ConsensusBlock: beaconBlock,
+			ExecutionBlock: state.ElBlockNumber,
+		}
 
 		// Approximate the staker's share of the smoothing pool balance
 		// NOTE: this will use the "vanilla" variant of treegen, without rolling records, to retain parity with other Oracle DAO nodes that aren't using rolling records
-		treegen, err := rprewards.NewTreeGenerator(t.log, "[Balances]", client, t.cfg, t.bc, currentIndex, startTime, endTime, beaconBlock, elBlockHeader, uint64(intervalsPassed), state, nil)
+		treegen, err := rprewards.NewTreeGenerator(t.log, "[Balances]", client, t.cfg, t.bc, currentIndex, startTime, endTime, snapshotEnd, elBlockHeader, uint64(intervalsPassed), state, nil)
 		if err != nil {
 			return fmt.Errorf("error creating merkle tree generator to approximate share of smoothing pool: %w", err)
 		}