feat: claim rewards from latest active root (#188)

* feat: claim rewards from last active root

* feat: cli support for using last active root for rewards

* fix comment

* readme update

Author: shrimalmadhur

pkg/rewards/README.md

@@ -4,14 +4,14 @@
 ```bash
 eigenlayer rewards claim --help
 NAME:
-   eigenlayer rewards claim - Claim rewards for the operator
+   eigenlayer rewards claim - Claim rewards for any earner
 
 USAGE:
    eigenlayer rewards claim [command options]
 
 OPTIONS:
    --broadcast, -b                                      Use this flag to broadcast the transaction (default: false) [$BROADCAST]
-   --claim-timestamp value, -c value                    Specify the timestamp. Only 'latest' is supported (default: "latest") [$CLAIM_TIMESTAMP]
+   --claim-timestamp value, -c value                    Specify the timestamp. Only 'latest' and 'latest_active' are supported (default: "latest") [$CLAIM_TIMESTAMP]
    --earner-address value, --ea value                   Address of the earner [$REWARDS_EARNER_ADDRESS]
    --ecdsa-private-key value, -e value                  ECDSA private key hex to send transaction [$ECDSA_PRIVATE_KEY]
    --environment value, --env value                     Environment to use. Currently supports 'preprod' ,'testnet' and 'prod'. If not provided, it will be inferred based on network [$ENVIRONMENT]

pkg/rewards/claim.go

@@ -1,6 +1,7 @@
 package rewards
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -19,6 +20,7 @@ import (
 	contractrewardscoordinator "github.com/Layr-Labs/eigenlayer-contracts/pkg/bindings/IRewardsCoordinator"
 
 	"github.com/Layr-Labs/eigenlayer-rewards-proofs/pkg/claimgen"
+	"github.com/Layr-Labs/eigenlayer-rewards-proofs/pkg/proofDataFetcher"
 	"github.com/Layr-Labs/eigenlayer-rewards-proofs/pkg/proofDataFetcher/httpProofDataFetcher"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/elcontracts"
@@ -35,8 +37,6 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
-const LatestClaimTimestamp = "latest"
-
 type ClaimConfig struct {
 	Network                   string
 	RPCUrl                    string
@@ -122,20 +122,11 @@ func Claim(cCtx *cli.Context, p utils.Prompter) error {
 		http.DefaultClient,
 	)
 
-	latestSubmittedTimestamp, err := elReader.CurrRewardsCalculationEndTimestamp(&bind.CallOpts{})
-	if err != nil {
-		return eigenSdkUtils.WrapError("failed to get latest submitted timestamp", err)
-	}
-	claimDate := time.Unix(int64(latestSubmittedTimestamp), 0).UTC().Format(time.DateOnly)
-	logger.Debugf("Latest submitted timestamp: %s", claimDate)
-
-	rootCount, err := elReader.GetDistributionRootsLength(&bind.CallOpts{})
+	claimDate, rootIndex, err := getClaimDistributionRoot(ctx, config.ClaimTimestamp, df, elReader, logger)
 	if err != nil {
-		return eigenSdkUtils.WrapError("failed to get number of published roots", err)
+		return eigenSdkUtils.WrapError("failed to get claim distribution root", err)
 	}
 
-	rootIndex := uint32(rootCount.Uint64() - 1)
-
 	proofData, err := df.FetchClaimAmountsForDate(ctx, claimDate)
 	if err != nil {
 		return eigenSdkUtils.WrapError("failed to fetch claim amounts for date", err)
@@ -264,6 +255,64 @@ func Claim(cCtx *cli.Context, p utils.Prompter) error {
 	return nil
 }
 
+func getClaimDistributionRoot(
+	ctx context.Context,
+	claimTimestamp string,
+	df *httpProofDataFetcher.HttpProofDataFetcher,
+	elReader *elcontracts.ChainReader,
+	logger logging.Logger,
+) (string, uint32, error) {
+	if claimTimestamp == "latest" {
+		latestSubmittedTimestamp, err := elReader.CurrRewardsCalculationEndTimestamp(&bind.CallOpts{})
+		if err != nil {
+			return "", 0, eigenSdkUtils.WrapError("failed to get latest submitted timestamp", err)
+		}
+		claimDate := time.Unix(int64(latestSubmittedTimestamp), 0).UTC().Format(time.DateOnly)
+		logger.Debugf("Latest submitted timestamp: %s", claimDate)
+
+		rootCount, err := elReader.GetDistributionRootsLength(&bind.CallOpts{})
+		if err != nil {
+			return "", 0, eigenSdkUtils.WrapError("failed to get number of published roots", err)
+		}
+
+		rootIndex := uint32(rootCount.Uint64() - 1)
+		return claimDate, rootIndex, nil
+	} else if claimTimestamp == "latest_active" {
+		// Get the latest 10 roots
+		postedRoots, err := df.FetchPostedRewards(ctx)
+		if err != nil {
+			return "", 0, eigenSdkUtils.WrapError("failed to fetch posted rewards", err)
+		}
+
+		ts, rootIndex, err := getLatestActivePostedRoot(postedRoots)
+		if err != nil {
+			return "", 0, eigenSdkUtils.WrapError("failed to get latest active posted root", err)
+		}
+		logger.Debugf("Latest active posted root timestamp: %s, index: %d", ts, rootIndex)
+
+		return ts, rootIndex, nil
+	}
+	return "", 0, errors.New("invalid claim timestamp")
+}
+
+// getLatestActivePostedRoot returns the latest active posted root by sorting the roots by the latest calculated end
+// timestamp in descending order and checking the latest timestamp which activated before the current time
+func getLatestActivePostedRoot(postedRoots []*proofDataFetcher.SubmittedRewardRoot) (string, uint32, error) {
+	// sort by latest calculated end timestamp
+	sort.Slice(postedRoots, func(i, j int) bool {
+		return postedRoots[i].CalcEndTimestamp.After(postedRoots[j].CalcEndTimestamp)
+	})
+
+	currTime := time.Now()
+	for _, postedRoot := range postedRoots {
+		if postedRoot.ActivatedAt.Before(currTime) {
+			return postedRoot.GetRewardDate(), postedRoot.RootIndex, nil
+		}
+		// There is no else here because on of last 10 root be
+	}
+	return "", 0, errors.New("no active posted roots found")
+}
+
 func convertClaimTokenLeaves(
 	claimTokenLeaves []contractrewardscoordinator.IRewardsCoordinatorTokenTreeMerkleLeaf,
 ) []rewardscoordinator.IRewardsCoordinatorTokenTreeMerkleLeaf {
@@ -300,9 +349,7 @@ func readAndValidateClaimConfig(cCtx *cli.Context, logger logging.Logger) (*Clai
 	logger.Debugf("Using Rewards Coordinator address: %s", rewardsCoordinatorAddress)
 
 	claimTimestamp := cCtx.String(ClaimTimestampFlag.Name)
-	if claimTimestamp != LatestClaimTimestamp {
-		return nil, errors.New("claim-timestamp must be 'latest'")
-	}
+	logger.Debugf("Using claim timestamp from user: %s", claimTimestamp)
 
 	recipientAddress := gethcommon.HexToAddress(cCtx.String(RecipientAddressFlag.Name))
 	if recipientAddress == utils.ZeroAddress {
@@ -357,6 +404,7 @@ func readAndValidateClaimConfig(cCtx *cli.Context, logger logging.Logger) (*Clai
 		Environment:               environment,
 		RecipientAddress:          recipientAddress,
 		SignerConfig:              signerConfig,
+		ClaimTimestamp:            claimTimestamp,
 	}, nil
 }
 

pkg/rewards/claim_test.go

@@ -4,10 +4,12 @@ import (
 	"flag"
 	"os"
 	"testing"
+	"time"
 
-	"github.com/Layr-Labs/eigenlayer-cli/pkg/internal/testutils"
+	"github.com/Layr-Labs/eigenlayer-rewards-proofs/pkg/proofDataFetcher"
 
 	"github.com/Layr-Labs/eigenlayer-cli/pkg/internal/common/flags"
+	"github.com/Layr-Labs/eigenlayer-cli/pkg/internal/testutils"
 
 	"github.com/Layr-Labs/eigensdk-go/logging"
 
@@ -53,3 +55,83 @@ func TestReadAndValidateConfig_RecipientProvided(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, common.HexToAddress(recipientAddress), config.RecipientAddress)
 }
+
+func TestGetLatestActivePostedRoot(t *testing.T) {
+	now := time.Now().UTC()
+	var tests = []struct {
+		name                   string
+		postedRoots            []*proofDataFetcher.SubmittedRewardRoot
+		expectedRootIndex      uint32
+		rewardsTimestampString string
+	}{
+		{
+			name: "found an activated root before current time",
+			postedRoots: []*proofDataFetcher.SubmittedRewardRoot{
+				{
+					RootIndex:        1,
+					ActivatedAt:      now,
+					CalcEndTimestamp: now.Add(-24 * time.Hour),
+				},
+				{
+					RootIndex:        2,
+					ActivatedAt:      now.Add(-2 * time.Hour),
+					CalcEndTimestamp: now.Add(-48 * time.Hour),
+				},
+				{
+					RootIndex:        3,
+					ActivatedAt:      now.Add(1 * time.Hour),
+					CalcEndTimestamp: now,
+				},
+			},
+			expectedRootIndex:      1,
+			rewardsTimestampString: now.Add(-24 * time.Hour).Format(time.DateOnly),
+		},
+		{
+			name: "found no activated root before current time",
+			postedRoots: []*proofDataFetcher.SubmittedRewardRoot{
+				{
+					RootIndex:        3,
+					ActivatedAt:      now.Add(1 * time.Hour),
+					CalcEndTimestamp: now,
+				},
+				{
+					RootIndex:        4,
+					ActivatedAt:      now.Add(2 * time.Hour),
+					CalcEndTimestamp: now.Add(3 * time.Hour),
+				},
+			},
+			expectedRootIndex: 0,
+		},
+		{
+			name: "found an activated root before current time 2",
+			postedRoots: []*proofDataFetcher.SubmittedRewardRoot{
+				{
+					RootIndex:        2,
+					ActivatedAt:      now.Add(-2 * time.Hour),
+					CalcEndTimestamp: now.Add(-24 * time.Hour),
+				},
+				{
+					RootIndex:        3,
+					ActivatedAt:      now.Add(1 * time.Hour),
+					CalcEndTimestamp: now.Add(-48 * time.Hour),
+				},
+			},
+			expectedRootIndex:      2,
+			rewardsTimestampString: now.Add(-24 * time.Hour).Format(time.DateOnly),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			actualRewardTimeString, actualRootIndex, err := getLatestActivePostedRoot(tt.postedRoots)
+			if tt.expectedRootIndex == 0 {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.rewardsTimestampString, actualRewardTimeString)
+			}
+			assert.Equal(t, tt.expectedRootIndex, actualRootIndex)
+
+		})
+	}
+}

pkg/rewards/flags.go

@@ -21,7 +21,7 @@ var (
 	ClaimTimestampFlag = cli.StringFlag{
 		Name:    "claim-timestamp",
 		Aliases: []string{"c"},
-		Usage:   "Specify the timestamp. Only 'latest' is supported",
+		Usage:   "Specify the timestamp. Only 'latest' and 'latest_active' are supported",
 		Value:   "latest",
 		EnvVars: []string{"CLAIM_TIMESTAMP"},
 	}