update with latest contracts

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.20241023023134-a285de543731
+	github.com/Layr-Labs/eigensdk-go v0.1.14-0.20241119232818-f7ce982c899e
 	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

@@ -12,8 +12,8 @@ github.com/Layr-Labs/eigenlayer-rewards-proofs v0.2.12 h1:G5Q1SnLmFbEjhOkky3vIHk
 github.com/Layr-Labs/eigenlayer-rewards-proofs v0.2.12/go.mod h1:OlJd1QjqEW53wfWG/lJyPCGvrXwWVEjPQsP4TV+gttQ=
 github.com/Layr-Labs/eigenpod-proofs-generation v0.0.14-stable.0.20240730152248-5c11a259293e h1:DvW0/kWHV9mZsbH2KOjEHKTSIONNPUj6X05FJvUohy4=
 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.20241023023134-a285de543731 h1:8F/wlaQoZG1+BcuP9cWhqKNbYgw4CphZFwp8SjMkW9A=
-github.com/Layr-Labs/eigensdk-go v0.1.13-0.20241023023134-a285de543731/go.mod h1:aYdNURUhaqeYOS+Cq12TfSdPbjFfiLaHkxPdR4Exq/s=
+github.com/Layr-Labs/eigensdk-go v0.1.14-0.20241119232818-f7ce982c899e h1:37FO9Rtc6XW5apFUfac4k03TBx+s2h8XqD5WdqOKjoA=
+github.com/Layr-Labs/eigensdk-go v0.1.14-0.20241119232818-f7ce982c899e/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,7 +90,7 @@ var (
 		EnvVars: []string{"EXPIRY"},
 		Value:   3600,
 	}
-	
+
 	OperatorAddressFlag = cli.StringFlag{
 		Name:    "operator-address",
 		Aliases: []string{"oa", "operator"},

pkg/operator/allocations/show.go

@@ -15,7 +15,6 @@ import (
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	eigenSdkUtils "github.com/Layr-Labs/eigensdk-go/utils"
 
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	gethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 
@@ -77,7 +76,7 @@ func showAction(cCtx *cli.Context, p utils.Prompter) error {
 	*/
 	for _, strategyAddress := range config.strategyAddresses {
 		allocatableMagnitude, err := elReader.GetAllocatableMagnitude(
-			&bind.CallOpts{Context: ctx},
+			ctx,
 			config.operatorAddress,
 			strategyAddress,
 		)
@@ -96,7 +95,7 @@ func showAction(cCtx *cli.Context, p utils.Prompter) error {
 	*/
 	totalMagnitudeMap := make(map[string]uint64)
 	totalMagnitudes, err := elReader.GetMaxMagnitudes(
-		&bind.CallOpts{Context: ctx},
+		ctx,
 		config.operatorAddress,
 		config.strategyAddresses,
 	)
@@ -114,7 +113,7 @@ func showAction(cCtx *cli.Context, p utils.Prompter) error {
 	allAllocations := make(map[string][]elcontracts.AllocationInfo, len(config.strategyAddresses))
 	for _, strategyAddress := range config.strategyAddresses {
 		allocations, err := elReader.GetAllocationInfo(
-			&bind.CallOpts{Context: ctx},
+			ctx,
 			config.operatorAddress,
 			strategyAddress,
 		)
@@ -128,7 +127,7 @@ func showAction(cCtx *cli.Context, p utils.Prompter) error {
 		6. Get the operator scaled shares for all strategies
 	*/
 	operatorDelegatedSharesMap := make(map[string]*big.Int)
-	shares, err := elReader.GetOperatorShares(&bind.CallOpts{}, config.operatorAddress, config.strategyAddresses)
+	shares, err := elReader.GetOperatorShares(ctx, config.operatorAddress, config.strategyAddresses)
 	for i, strategyAddress := range config.strategyAddresses {
 		operatorDelegatedSharesMap[strategyAddress.String()] = shares[i]
 	}
@@ -141,7 +140,10 @@ func showAction(cCtx *cli.Context, p utils.Prompter) error {
 	for strategy, allocations := range allAllocations {
 		strategyShares := operatorDelegatedSharesMap[strategy]
 		for _, alloc := range allocations {
-			currentShares, currentSharesPercentage := getSharesFromMagnitude(strategyShares, alloc.CurrentMagnitude.Uint64())
+			currentShares, currentSharesPercentage := getSharesFromMagnitude(
+				strategyShares,
+				alloc.CurrentMagnitude.Uint64(),
+			)
 			newMagnitudeBigInt := big.NewInt(0)
 			if alloc.PendingDiff.Cmp(big.NewInt(0)) != 0 {
 				newMagnitudeBigInt = big.NewInt(0).Add(alloc.CurrentMagnitude, alloc.PendingDiff)
@@ -155,7 +157,7 @@ func showAction(cCtx *cli.Context, p utils.Prompter) error {
 				Shares:                   currentShares,
 				SharesPercentage:         currentSharesPercentage.String(),
 				NewMagnitude:             newMagnitudeBigInt.Uint64(),
-				NewMagnitudeTimestamp:    alloc.CompletableTimestamp,
+				NewMagnitudeTimestamp:    alloc.EffectBlock,
 				NewAllocationShares:      newShares,
 				UpcomingSharesPercentage: newSharesPercentage.String(),
 			})
@@ -273,7 +275,7 @@ func getSharesFromMagnitude(totalScaledShare *big.Int, magnitude uint64) (*big.I
 }
 
 func getUniqueKey(strategyAddress gethcommon.Address, opSet allocationmanager.OperatorSet) string {
-	return fmt.Sprintf("%s-%s-%d", strategyAddress.String(), opSet.Avs.String(), opSet.OperatorSetId)
+	return fmt.Sprintf("%s-%s-%d", strategyAddress.String(), opSet.Avs.String(), opSet.Id)
 }
 
 func readAndValidateShowConfig(cCtx *cli.Context, logger *logging.Logger) (*showConfig, error) {

pkg/operator/allocations/types.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/Layr-Labs/eigenlayer-cli/pkg/internal/common"
-
 	"github.com/Layr-Labs/eigenlayer-cli/pkg/types"
 
 	allocationmanager "github.com/Layr-Labs/eigensdk-go/contracts/bindings/AllocationManager"
@@ -17,7 +16,7 @@ import (
 )
 
 type BulkModifyAllocations struct {
-	Allocations           []allocationmanager.IAllocationManagerTypesMagnitudeAllocation
+	Allocations           []allocationmanager.IAllocationManagerTypesAllocateParams
 	AllocatableMagnitudes map[gethcommon.Address]uint64
 }
 
@@ -28,13 +27,12 @@ func (b *BulkModifyAllocations) PrintPretty() {
 	allocations := b.Allocations
 	headers := []string{
 		"Strategy",
-		"Expected Total Magnitude",
 		"Allocatable Magnitude",
 		"Operator Set ID",
 		"AVS",
 		"Magnitude",
 	}
-	widths := []int{20, 25, 25, 20, 20, 25}
+	widths := []int{20, 25, 20, 20, 25}
 
 	// print dashes
 	for _, width := range widths {
@@ -59,21 +57,19 @@ func (b *BulkModifyAllocations) PrintPretty() {
 
 	// Print data rows
 	for _, a := range allocations {
-		for i, opSet := range a.OperatorSets {
+		for i, strategy := range a.Strategies {
 			fmt.Printf(
 				"| %-*s| %-*s| %-*s| %-*d| %-*s| %-*s|\n",
 				widths[0],
-				common.ShortEthAddress(a.Strategy),
+				common.ShortEthAddress(strategy),
 				widths[1],
-				common.FormatNumberWithUnderscores(common.Uint64ToString(a.ExpectedMaxMagnitude)),
+				common.FormatNumberWithUnderscores(common.Uint64ToString(b.AllocatableMagnitudes[strategy])),
 				widths[2],
-				common.FormatNumberWithUnderscores(common.Uint64ToString(b.AllocatableMagnitudes[a.Strategy])),
+				a.OperatorSet.Id,
 				widths[3],
-				opSet.OperatorSetId,
+				common.ShortEthAddress(a.OperatorSet.Avs),
 				widths[4],
-				common.ShortEthAddress(opSet.Avs),
-				widths[5],
-				common.FormatNumberWithUnderscores(common.Uint64ToString(a.Magnitudes[i])),
+				common.FormatNumberWithUnderscores(common.Uint64ToString(a.NewMagnitudes[i])),
 			)
 		}
 	}

pkg/operator/allocations/update.go

@@ -9,7 +9,6 @@ import (
 	"sort"
 	"sync"
 
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	gethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 
@@ -29,12 +28,12 @@ import (
 
 type elChainReader interface {
 	GetMaxMagnitudes(
-		opts *bind.CallOpts,
+		ctx context.Context,
 		operatorAddress gethcommon.Address,
 		strategyAddresses []gethcommon.Address,
 	) ([]uint64, error)
 	GetAllocatableMagnitude(
-		opts *bind.CallOpts,
+		ctx context.Context,
 		operator gethcommon.Address,
 		strategy gethcommon.Address,
 	) (uint64, error)
@@ -200,21 +199,21 @@ func generateAllocationsParams(
 	config *updateConfig,
 	logger logging.Logger,
 ) (*BulkModifyAllocations, error) {
-	allocations := make([]allocationmanager.IAllocationManagerTypesMagnitudeAllocation, 0)
+	allocations := make([]allocationmanager.IAllocationManagerTypesAllocateParams, 0)
 	var allocatableMagnitudes map[gethcommon.Address]uint64
 
 	var err error
 	if len(config.csvFilePath) == 0 {
 		magnitude, err := elReader.GetMaxMagnitudes(
-			&bind.CallOpts{Context: ctx},
+			ctx,
 			config.operatorAddress,
 			[]gethcommon.Address{config.strategyAddress},
 		)
 		if err != nil {
 			return nil, eigenSdkUtils.WrapError("failed to get latest total magnitude", err)
 		}
 		allocatableMagnitude, err := elReader.GetAllocatableMagnitude(
-			&bind.CallOpts{Context: ctx},
+			ctx,
 			config.operatorAddress,
 			config.strategyAddress,
 		)
@@ -226,16 +225,13 @@ func generateAllocationsParams(
 		logger.Debugf("Bips to allocate: %d", config.bipsToAllocate)
 		magnitudeToUpdate := calculateMagnitudeToUpdate(magnitude[0], config.bipsToAllocate)
 		logger.Debugf("Magnitude to update: %d", magnitudeToUpdate)
-		malloc := allocationmanager.IAllocationManagerTypesMagnitudeAllocation{
-			Strategy:             config.strategyAddress,
-			ExpectedMaxMagnitude: magnitude[0],
-			OperatorSets: []allocationmanager.OperatorSet{
-				{
-					Avs:           config.avsAddress,
-					OperatorSetId: config.operatorSetId,
-				},
+		malloc := allocationmanager.IAllocationManagerTypesAllocateParams{
+			Strategies: []gethcommon.Address{config.strategyAddress},
+			OperatorSet: allocationmanager.OperatorSet{
+				Avs: config.avsAddress,
+				Id:  config.operatorSetId,
 			},
-			Magnitudes: []uint64{magnitudeToUpdate},
+			NewMagnitudes: []uint64{magnitudeToUpdate},
 		}
 		allocations = append(allocations, malloc)
 	} else {
@@ -255,7 +251,7 @@ func computeAllocations(
 	filePath string,
 	operatorAddress gethcommon.Address,
 	elReader elChainReader,
-) ([]allocationmanager.IAllocationManagerTypesMagnitudeAllocation, map[gethcommon.Address]uint64, error) {
+) ([]allocationmanager.IAllocationManagerTypesAllocateParams, map[gethcommon.Address]uint64, error) {
 	allocations, err := parseAllocationsCSV(filePath)
 	if err != nil {
 		return nil, nil, eigenSdkUtils.WrapError("failed to parse allocations csv", err)
@@ -314,7 +310,7 @@ func parallelGetAllocatableMagnitudes(
 		wg.Add(1)
 		go func(strategy gethcommon.Address) {
 			defer wg.Done()
-			magnitude, err := elReader.GetAllocatableMagnitude(&bind.CallOpts{}, operatorAddress, strategy)
+			magnitude, err := elReader.GetAllocatableMagnitude(context.Background(), operatorAddress, strategy)
 			if err != nil {
 				errChan <- err
 				return
@@ -340,7 +336,7 @@ func getMagnitudes(
 ) (map[gethcommon.Address]uint64, error) {
 	strategyTotalMagnitudes := make(map[gethcommon.Address]uint64, len(strategies))
 	totalMagnitudes, err := reader.GetMaxMagnitudes(
-		&bind.CallOpts{Context: context.Background()},
+		context.Background(),
 		operatorAddress,
 		strategies,
 	)
@@ -385,40 +381,62 @@ func parseAllocationsCSV(filePath string) ([]allocation, error) {
 func convertAllocationsToMagnitudeAllocations(
 	allocations []allocation,
 	strategyTotalMagnitudes map[gethcommon.Address]uint64,
-) []allocationmanager.IAllocationManagerTypesMagnitudeAllocation {
-	magnitudeAllocations := make([]allocationmanager.IAllocationManagerTypesMagnitudeAllocation, 0)
-	operatorSetsPerStragyMap := make(map[gethcommon.Address][]allocationmanager.OperatorSet)
-	magnitudeAllocationsPerStrategyMap := make(map[gethcommon.Address][]uint64)
+) []allocationmanager.IAllocationManagerTypesAllocateParams {
+	magnitudeAllocations := make([]allocationmanager.IAllocationManagerTypesAllocateParams, 0)
+	//operatorSetsPerStragyMap := make(map[gethcommon.Address][]allocationmanager.OperatorSet)
+	strategiesPerOperatorSetMap := make(map[allocationmanager.OperatorSet][]gethcommon.Address)
+	//magnitudeAllocationsPerStrategyMap := make(map[gethcommon.Address][]uint64)
+	magnitudeAllocationsPerOperatorSetMap := make(map[allocationmanager.OperatorSet][]uint64)
 	for _, a := range allocations {
 		totalMag := strategyTotalMagnitudes[a.StrategyAddress]
 		magnitudeToUpdate := calculateMagnitudeToUpdate(totalMag, a.Bips)
 
-		operatorSets, ok := operatorSetsPerStragyMap[a.StrategyAddress]
+		opSet := allocationmanager.OperatorSet{Avs: a.AvsAddress, Id: a.OperatorSetId}
+		strategies, ok := strategiesPerOperatorSetMap[opSet]
 		if !ok {
-			operatorSets = make([]allocationmanager.OperatorSet, 0)
+			strategies = make([]gethcommon.Address, 0)
 		}
-		operatorSets = append(operatorSets, allocationmanager.OperatorSet{
-			Avs:           a.AvsAddress,
-			OperatorSetId: a.OperatorSetId,
-		})
-		operatorSetsPerStragyMap[a.StrategyAddress] = operatorSets
 
-		magnitudes := magnitudeAllocationsPerStrategyMap[a.StrategyAddress]
+		strategies = append(strategies, a.StrategyAddress)
+		strategiesPerOperatorSetMap[opSet] = strategies
+
+		//operatorSets, ok := operatorSetsPerStragyMap[a.StrategyAddress]
+		//if !ok {
+		//	operatorSets = make([]allocationmanager.OperatorSet, 0)
+		//}
+		//operatorSets = append(operatorSets, allocationmanager.OperatorSet{
+		//	Avs: a.AvsAddress,
+		//	Id:  a.OperatorSetId,
+		//})
+		//operatorSetsPerStragyMap[a.StrategyAddress] = operatorSets
+
+		magnitudes := magnitudeAllocationsPerOperatorSetMap[opSet]
 		magnitudes = append(magnitudes, magnitudeToUpdate)
-		magnitudeAllocationsPerStrategyMap[a.StrategyAddress] = magnitudes
+		magnitudeAllocationsPerOperatorSetMap[opSet] = magnitudes
 	}
 
-	for strategy, operatorSets := range operatorSetsPerStragyMap {
+	for opSet, strategies := range strategiesPerOperatorSetMap {
 		magnitudeAllocations = append(
 			magnitudeAllocations,
-			allocationmanager.IAllocationManagerTypesMagnitudeAllocation{
-				Strategy:             strategy,
-				ExpectedMaxMagnitude: strategyTotalMagnitudes[strategy],
-				OperatorSets:         operatorSets,
-				Magnitudes:           magnitudeAllocationsPerStrategyMap[strategy],
+			allocationmanager.IAllocationManagerTypesAllocateParams{
+				OperatorSet:   opSet,
+				Strategies:    strategies,
+				NewMagnitudes: magnitudeAllocationsPerOperatorSetMap[opSet],
 			},
 		)
 	}
+
+	//for strategy, operatorSets := range operatorSetsPerStragyMap {
+	//	magnitudeAllocations = append(
+	//		magnitudeAllocations,
+	//		allocationmanager.IAllocationManagerTypesAllocateParams{
+	//			Strategy:             strategy,
+	//			ExpectedMaxMagnitude: strategyTotalMagnitudes[strategy],
+	//			OperatorSets:         operatorSets,
+	//			Magnitudes:           magnitudeAllocationsPerStrategyMap[strategy],
+	//		},
+	//	)
+	//}
 	return magnitudeAllocations
 }
 

pkg/operator/allocations/update_test.go

@@ -98,7 +98,7 @@ func TestGenerateAllocationsParams(t *testing.T) {
 			},
 			expectError: false,
 			expectedAllocations: &BulkModifyAllocations{
-				Allocations: []allocationmanager.IAllocationManagerTypesMagnitudeAllocation{
+				Allocations: []allocationmanager.IAllocationManagerTypesAllocateParams{
 					{
 						Strategy:             gethcommon.HexToAddress(strategyAddress),
 						ExpectedMaxMagnitude: initialMagnitude,
@@ -121,7 +121,7 @@ func TestGenerateAllocationsParams(t *testing.T) {
 			},
 			expectError: false,
 			expectedAllocations: &BulkModifyAllocations{
-				Allocations: []allocationmanager.IAllocationManagerTypesMagnitudeAllocation{
+				Allocations: []allocationmanager.IAllocationManagerTypesAllocateParams{
 					{
 						Strategy:             gethcommon.HexToAddress("0x49989b32351Eb9b8ab2d5623cF22E7F7C23e5630"),
 						ExpectedMaxMagnitude: initialMagnitude,

pkg/rewards/claim.go

@@ -39,7 +39,7 @@ type elChainReader interface {
 	GetRootIndexFromHash(ctx context.Context, hash [32]byte) (uint32, error)
 	GetCurrentClaimableDistributionRoot(
 		ctx context.Context,
-	) (rewardscoordinator.IRewardsCoordinatorDistributionRoot, error)
+	) (rewardscoordinator.IRewardsCoordinatorTypesDistributionRoot, error)
 	CurrRewardsCalculationEndTimestamp(ctx context.Context) (uint32, error)
 }
 
@@ -138,11 +138,11 @@ func Claim(cCtx *cli.Context, p utils.Prompter) error {
 		return eigenSdkUtils.WrapError("failed to generate claim proof for earner", err)
 	}
 
-	elClaim := rewardscoordinator.IRewardsCoordinatorRewardsMerkleClaim{
+	elClaim := rewardscoordinator.IRewardsCoordinatorTypesRewardsMerkleClaim{
 		RootIndex:       claim.RootIndex,
 		EarnerIndex:     claim.EarnerIndex,
 		EarnerTreeProof: claim.EarnerTreeProof,
-		EarnerLeaf: rewardscoordinator.IRewardsCoordinatorEarnerTreeMerkleLeaf{
+		EarnerLeaf: rewardscoordinator.IRewardsCoordinatorTypesEarnerTreeMerkleLeaf{
 			Earner:          claim.EarnerLeaf.Earner,
 			EarnerTokenRoot: claim.EarnerLeaf.EarnerTokenRoot,
 		},
@@ -345,10 +345,10 @@ func filterClaimableTokenAddresses(
 
 func convertClaimTokenLeaves(
 	claimTokenLeaves []contractrewardscoordinator.IRewardsCoordinatorTokenTreeMerkleLeaf,
-) []rewardscoordinator.IRewardsCoordinatorTokenTreeMerkleLeaf {
-	var tokenLeaves []rewardscoordinator.IRewardsCoordinatorTokenTreeMerkleLeaf
+) []rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf {
+	var tokenLeaves []rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf
 	for _, claimTokenLeaf := range claimTokenLeaves {
-		tokenLeaves = append(tokenLeaves, rewardscoordinator.IRewardsCoordinatorTokenTreeMerkleLeaf{
+		tokenLeaves = append(tokenLeaves, rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf{
 			Token:              claimTokenLeaf.Token,
 			CumulativeEarnings: claimTokenLeaf.CumulativeEarnings,
 		})