feat: Rewards v2 batch claiming support

go.mod

@@ -7,7 +7,7 @@ require (
 	github.com/Layr-Labs/eigenlayer-contracts v0.3.2-mainnet-rewards
 	github.com/Layr-Labs/eigenlayer-rewards-proofs v0.2.12
 	github.com/Layr-Labs/eigenpod-proofs-generation v0.0.14-stable.0.20240730152248-5c11a259293e
-	github.com/Layr-Labs/eigensdk-go v0.1.13-0.20241023200243-565bb4438918
+	github.com/Layr-Labs/eigensdk-go v0.1.14-0.20241121204729-7d2cd162ffe8
 	github.com/blang/semver/v4 v4.0.0
 	github.com/consensys/gnark-crypto v0.12.1
 	github.com/ethereum/go-ethereum v1.14.5

go.sum

@@ -14,6 +14,8 @@ github.com/Layr-Labs/eigenpod-proofs-generation v0.0.14-stable.0.20240730152248-
 github.com/Layr-Labs/eigenpod-proofs-generation v0.0.14-stable.0.20240730152248-5c11a259293e/go.mod h1:T7tYN8bTdca2pkMnz9G2+ZwXYWw5gWqQUIu4KLgC/vM=
 github.com/Layr-Labs/eigensdk-go v0.1.13-0.20241023200243-565bb4438918 h1:Itl141PoMFzq58ZTo4Nu/CyH+x8f4BH6OmBNhZ6Z2/I=
 github.com/Layr-Labs/eigensdk-go v0.1.13-0.20241023200243-565bb4438918/go.mod h1:aYdNURUhaqeYOS+Cq12TfSdPbjFfiLaHkxPdR4Exq/s=
+github.com/Layr-Labs/eigensdk-go v0.1.14-0.20241121204729-7d2cd162ffe8 h1:6wuVq+Elto+yF7bQ3QYqD2psxGXR3wcJh2koNcUjIQM=
+github.com/Layr-Labs/eigensdk-go v0.1.14-0.20241121204729-7d2cd162ffe8/go.mod h1:aYdNURUhaqeYOS+Cq12TfSdPbjFfiLaHkxPdR4Exq/s=
 github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
 github.com/Microsoft/hcsshim v0.11.4 h1:68vKo2VN8DE9AdN4tnkWnmdhqdbpUFM8OF3Airm7fz8=

pkg/internal/common/flags/general.go

@@ -90,4 +90,11 @@ var (
 		EnvVars: []string{"EXPIRY"},
 		Value:   3600,
 	}
+
+	BatchClaimFile = cli.StringFlag{
+		Name:    "batch-claim-file",
+		Aliases: []string{"bcf"},
+		Usage:   "Input file for batch rewards claim",
+		EnvVars: []string{"BATCH_CLAIM_FILE"},
+	}
 )

pkg/rewards/claim.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"math/big"
 	"net/http"
+	"os"
 	"sort"
 	"strings"
 	"time"
@@ -15,6 +16,8 @@ import (
 	"github.com/Layr-Labs/eigenlayer-cli/pkg/internal/common/flags"
 	"github.com/Layr-Labs/eigenlayer-cli/pkg/telemetry"
 	"github.com/Layr-Labs/eigenlayer-cli/pkg/utils"
+	"github.com/wealdtech/go-merkletree/v2"
+	"gopkg.in/yaml.v2"
 
 	contractrewardscoordinator "github.com/Layr-Labs/eigenlayer-contracts/pkg/bindings/IRewardsCoordinator"
 
@@ -75,75 +78,145 @@ func getClaimFlags() []cli.Flag {
 		&ProofStoreBaseURLFlag,
 		&flags.VerboseFlag,
 		&flags.SilentFlag,
+		&flags.BatchClaimFile,
 	}
 
 	allFlags := append(baseFlags, flags.GetSignerFlags()...)
 	sort.Sort(cli.FlagsByName(allFlags))
 	return allFlags
 }
 
-func Claim(cCtx *cli.Context, p utils.Prompter) error {
+func BatchClaim(
+	cCtx *cli.Context,
+	ethClient *ethclient.Client,
+	elReader *elcontracts.ChainReader,
+	df *httpProofDataFetcher.HttpProofDataFetcher,
+	config *ClaimConfig,
+	p utils.Prompter,
+) error {
 	ctx := cCtx.Context
 	logger := common.GetLogger(cCtx)
 
-	config, err := readAndValidateClaimConfig(cCtx, logger)
+	yamlFile, err := os.ReadFile(config.BatchClaimFile)
 	if err != nil {
-		return eigenSdkUtils.WrapError("failed to read and validate claim config", err)
+		return eigenSdkUtils.WrapError("failed to read YAML config file", err)
 	}
-	cCtx.App.Metadata["network"] = config.ChainID.String()
 
-	ethClient, err := ethclient.Dial(config.RPCUrl)
-	if err != nil {
-		return eigenSdkUtils.WrapError("failed to create new eth client", err)
+	var claimConfigs []struct {
+		EarnerAddress  string   `yaml:"earner_address"`
+		TokenAddresses []string `yaml:"token_addresses"`
 	}
 
-	elReader, err := elcontracts.NewReaderFromConfig(
-		elcontracts.Config{
-			RewardsCoordinatorAddress: config.RewardsCoordinatorAddress,
-		},
-		ethClient, logger,
-	)
+	err = yaml.Unmarshal(yamlFile, &claimConfigs)
 	if err != nil {
-		return eigenSdkUtils.WrapError("failed to create new reader from config", err)
+		return eigenSdkUtils.WrapError("failed to parse YAML config", err)
 	}
 
-	df := httpProofDataFetcher.NewHttpProofDataFetcher(
-		config.ProofStoreBaseURL,
-		config.Environment,
-		config.Network,
-		http.DefaultClient,
-	)
+	var elClaims []rewardscoordinator.IRewardsCoordinatorRewardsMerkleClaim
+
+	for _, claimConfig := range claimConfigs {
+		earnerAddr := gethcommon.HexToAddress(claimConfig.EarnerAddress)
+
+		var tokenAddrs []gethcommon.Address
+
+		// Empty token addresses list will create a claim for all tokens claimable
+		// by the earner address.
+		if len(claimConfig.TokenAddresses) == 0 {
+			tokenAddrs = nil
+		} else {
+			for _, addr := range claimConfig.TokenAddresses {
+				tokenAddrs = append(tokenAddrs, gethcommon.HexToAddress(addr))
+			}
+		}
+
+		elClaim, _, _, err := generateClaimPayload(
+			ctx,
+			config.ClaimTimestamp,
+			elReader,
+			logger,
+			earnerAddr,
+			df,
+			tokenAddrs,
+		)
+
+		elClaims = append(elClaims, *elClaim)
+
+		if err != nil {
+			logger.Errorf("Failed to process claim for earner %s: %v", earnerAddr.String(), err)
+			continue
+		}
+	}
+
+	if config.Broadcast {
+		eLWriter, err := common.GetELWriter(
+			config.ClaimerAddress,
+			config.SignerConfig,
+			ethClient,
+			elcontracts.Config{
+				RewardsCoordinatorAddress: config.RewardsCoordinatorAddress,
+			},
+			p,
+			config.ChainID,
+			logger,
+		)
+
+		if err != nil {
+			return eigenSdkUtils.WrapError("failed to get EL writer", err)
+		}
+
+		logger.Infof("Broadcasting batch claim transaction...")
+		receipt, err := eLWriter.ProcessClaims(ctx, elClaims, config.RecipientAddress, true)
+		if err != nil {
+			return eigenSdkUtils.WrapError("failed to process claim", err)
+		}
+
+		logger.Infof("Claim transaction submitted successfully")
+		common.PrintTransactionInfo(receipt.TxHash.String(), config.ChainID)
+	} else {
+		return eigenSdkUtils.WrapError("Batch claim currently only supported with broadcast flag", err)
+	}
+	return nil
+}
 
-	claimDate, rootIndex, err := getClaimDistributionRoot(ctx, config.ClaimTimestamp, elReader, logger)
+func generateClaimPayload(
+	ctx context.Context,
+	claimTimestamp string,
+	elReader *elcontracts.ChainReader,
+	logger logging.Logger,
+	earnerAddress gethcommon.Address,
+	df *httpProofDataFetcher.HttpProofDataFetcher,
+	tokenAddresses []gethcommon.Address,
+) (*rewardscoordinator.IRewardsCoordinatorRewardsMerkleClaim, *contractrewardscoordinator.IRewardsCoordinatorRewardsMerkleClaim, *merkletree.MerkleTree, error) {
+	claimDate, rootIndex, err := getClaimDistributionRoot(ctx, claimTimestamp, elReader, logger)
 	if err != nil {
-		return eigenSdkUtils.WrapError("failed to get claim distribution root", err)
+		return nil, nil, nil, eigenSdkUtils.WrapError("failed to get claim distribution root", err)
 	}
 
 	proofData, err := df.FetchClaimAmountsForDate(ctx, claimDate)
 	if err != nil {
-		return eigenSdkUtils.WrapError("failed to fetch claim amounts for date", err)
+		return nil, nil, nil, eigenSdkUtils.WrapError("failed to fetch claim amounts for date", err)
 	}
 
-	claimableTokensOrderMap, present := proofData.Distribution.GetTokensForEarner(config.EarnerAddress)
+	claimableTokensOrderMap, present := proofData.Distribution.GetTokensForEarner(earnerAddress)
 	if !present {
-		return errors.New("no tokens claimable by earner")
+		return nil, nil, nil, errors.New("no tokens claimable by earner")
 	}
 
-	claimableTokensMap := getTokensToClaim(claimableTokensOrderMap, config.TokenAddresses)
+	claimableTokensMap := getTokensToClaim(claimableTokensOrderMap, tokenAddresses)
 
-	claimableTokens, err := filterClaimableTokens(ctx, elReader, config.EarnerAddress, claimableTokensMap)
+	claimableTokens, err := filterClaimableTokens(ctx, elReader, earnerAddress, claimableTokensMap)
 	if err != nil {
-		return eigenSdkUtils.WrapError("failed to get claimable tokens", err)
+		return nil, nil, nil, eigenSdkUtils.WrapError("failed to get claimable tokens", err)
 	}
 
 	cg := claimgen.NewClaimgen(proofData.Distribution)
 	accounts, claim, err := cg.GenerateClaimProofForEarner(
-		config.EarnerAddress,
+		earnerAddress,
 		claimableTokens,
 		rootIndex,
 	)
 	if err != nil {
-		return eigenSdkUtils.WrapError("failed to generate claim proof for earner", err)
+		return nil, nil, nil, eigenSdkUtils.WrapError("failed to generate claim proof for earner", err)
 	}
 
 	elClaim := rewardscoordinator.IRewardsCoordinatorRewardsMerkleClaim{
@@ -159,15 +232,69 @@ func Claim(cCtx *cli.Context, p utils.Prompter) error {
 		TokenLeaves:     convertClaimTokenLeaves(claim.TokenLeaves),
 	}
 
-	logger.Info("Validating claim proof...")
+	logger.Infof("Validating claim proof for earner %s...", earnerAddress)
 	ok, err := elReader.CheckClaim(ctx, elClaim)
 	if err != nil {
-		return err
+		return nil, nil, nil, err
 	}
 	if !ok {
-		return errors.New("failed to validate claim")
+		return nil, nil, nil, errors.New("failed to validate claim")
+	}
+	logger.Infof("Claim proof for earner %s validated successfully", earnerAddress)
+
+	return &elClaim, claim, accounts, nil
+}
+
+func Claim(cCtx *cli.Context, p utils.Prompter) error {
+	ctx := cCtx.Context
+	logger := common.GetLogger(cCtx)
+
+	config, err := readAndValidateClaimConfig(cCtx, logger)
+	if err != nil {
+		return eigenSdkUtils.WrapError("failed to read and validate claim config", err)
+	}
+
+	cCtx.App.Metadata["network"] = config.ChainID.String()
+
+	ethClient, err := ethclient.Dial(config.RPCUrl)
+	if err != nil {
+		return eigenSdkUtils.WrapError("failed to create new eth client", err)
+	}
+
+	elReader, err := elcontracts.NewReaderFromConfig(
+		elcontracts.Config{
+			RewardsCoordinatorAddress: config.RewardsCoordinatorAddress,
+		},
+		ethClient, logger,
+	)
+	if err != nil {
+		return eigenSdkUtils.WrapError("failed to create new reader from config", err)
+	}
+
+	df := httpProofDataFetcher.NewHttpProofDataFetcher(
+		config.ProofStoreBaseURL,
+		config.Environment,
+		config.Network,
+		http.DefaultClient,
+	)
+
+	if config.BatchClaimFile != "" {
+		return BatchClaim(cCtx, ethClient, elReader, df, config, p)
+	}
+
+	elClaim, claim, accounts, err := generateClaimPayload(
+		ctx,
+		config.ClaimTimestamp,
+		elReader,
+		logger,
+		config.EarnerAddress,
+		df,
+		config.TokenAddresses,
+	)
+
+	if err != nil {
+		return err
 	}
-	logger.Info("Claim proof validated successfully")
 
 	if config.Broadcast {
 		eLWriter, err := common.GetELWriter(
@@ -187,7 +314,7 @@ func Claim(cCtx *cli.Context, p utils.Prompter) error {
 		}
 
 		logger.Infof("Broadcasting claim transaction...")
-		receipt, err := eLWriter.ProcessClaim(ctx, elClaim, config.RecipientAddress, true)
+		receipt, err := eLWriter.ProcessClaim(ctx, *elClaim, config.RecipientAddress, true)
 		if err != nil {
 			return eigenSdkUtils.WrapError("failed to process claim", err)
 		}
@@ -216,7 +343,7 @@ func Claim(cCtx *cli.Context, p utils.Prompter) error {
 			noSendTxOpts.GasLimit = 150_000
 		}
 
-		unsignedTx, err := contractBindings.RewardsCoordinator.ProcessClaim(noSendTxOpts, elClaim, config.RecipientAddress)
+		unsignedTx, err := contractBindings.RewardsCoordinator.ProcessClaim(noSendTxOpts, *elClaim, config.RecipientAddress)
 		if err != nil {
 			return eigenSdkUtils.WrapError("failed to create unsigned tx", err)
 		}
@@ -406,6 +533,7 @@ func readAndValidateClaimConfig(cCtx *cli.Context, logger logging.Logger) (*Clai
 	validTokenAddresses := getValidHexAddresses(splitTokenAddresses)
 	rewardsCoordinatorAddress := cCtx.String(RewardsCoordinatorAddressFlag.Name)
 	isSilent := cCtx.Bool(flags.SilentFlag.Name)
+	batchClaimFile := cCtx.String(flags.BatchClaimFile.Name)
 
 	var err error
 	if common.IsEmptyString(rewardsCoordinatorAddress) {
@@ -490,6 +618,7 @@ func readAndValidateClaimConfig(cCtx *cli.Context, logger logging.Logger) (*Clai
 		ClaimTimestamp:            claimTimestamp,
 		ClaimerAddress:            claimerAddress,
 		IsSilent:                  isSilent,
+		BatchClaimFile:            batchClaimFile,
 	}, nil
 }
 

pkg/rewards/types.go

@@ -32,6 +32,7 @@ type ClaimConfig struct {
 	Environment               string
 	SignerConfig              *types.SignerConfig
 	IsSilent                  bool
+	BatchClaimFile            string
 }
 
 type SetClaimerConfig struct {

samples/batch-claims.yaml

@@ -0,0 +1,6 @@
+- earner_address: "0x025246421e7247a729bbcff652c5cc1815ac6373"
+  token_addresses:
+    - "0x3B78576F7D6837500bA3De27A60c7f594934027E"
+- earner_address: "0x025246421e7247a729bbcff652c5cc1815ac6373"
+  token_addresses:
+    - "0x3B78576F7D6837500bA3De27A60c7f594934027E"