Remove deprecated functions (#367)

Co-authored-by: Tomás Grüner <[email protected]>
Layr-Labs · Jan 17, 2025 · 83f8c28 · 83f8c28
1 parent ad30996
commit 83f8c28
Show file tree

Hide file tree

Showing 8 changed files with 0 additions and 366 deletions.
diff --git a/chainio/clients/avsregistry/bindings.go b/chainio/clients/avsregistry/bindings.go
@@ -38,91 +38,6 @@ type ContractBindings struct {
 	OperatorStateRetriever *opstateretriever.ContractOperatorStateRetriever
 }
 
-// NewAVSRegistryContractBindings creates a new instance of ContractBindings
-// Deprecated: Use NewBindingsFromConfig instead
-func NewAVSRegistryContractBindings(
-	registryCoordinatorAddr gethcommon.Address,
-	operatorStateRetrieverAddr gethcommon.Address,
-	ethclient eth.HttpBackend,
-	logger logging.Logger,
-) (*ContractBindings, error) {
-	contractBlsRegistryCoordinator, err := regcoordinator.NewContractRegistryCoordinator(
-		registryCoordinatorAddr,
-		ethclient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create BLSRegistryCoordinator contract", err)
-	}
-
-	serviceManagerAddr, err := contractBlsRegistryCoordinator.ServiceManager(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch ServiceManager address", err)
-	}
-	contractServiceManager, err := servicemanager.NewContractServiceManagerBase(
-		serviceManagerAddr,
-		ethclient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch ServiceManager contract", err)
-	}
-
-	stakeregistryAddr, err := contractBlsRegistryCoordinator.StakeRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch StakeRegistry address", err)
-	}
-	contractStakeRegistry, err := stakeregistry.NewContractStakeRegistry(
-		stakeregistryAddr,
-		ethclient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch StakeRegistry contract", err)
-	}
-
-	blsApkRegistryAddr, err := contractBlsRegistryCoordinator.BlsApkRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch BLSPubkeyRegistry address", err)
-	}
-	contractBlsApkRegistry, err := blsapkregistry.NewContractBLSApkRegistry(
-		blsApkRegistryAddr,
-		ethclient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch BLSPubkeyRegistry contract", err)
-	}
-
-	indexRegistryAddr, err := contractBlsRegistryCoordinator.IndexRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch IndexRegistry address", err)
-	}
-	contractIndexRegistry, err := indexregistry.NewContractIndexRegistry(indexRegistryAddr, ethclient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch IndexRegistry contract", err)
-	}
-
-	contractOperatorStateRetriever, err := opstateretriever.NewContractOperatorStateRetriever(
-		operatorStateRetrieverAddr,
-		ethclient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch OperatorStateRetriever contract", err)
-	}
-
-	return &ContractBindings{
-		ServiceManagerAddr:         serviceManagerAddr,
-		RegistryCoordinatorAddr:    registryCoordinatorAddr,
-		StakeRegistryAddr:          stakeregistryAddr,
-		BlsApkRegistryAddr:         blsApkRegistryAddr,
-		IndexRegistryAddr:          indexRegistryAddr,
-		OperatorStateRetrieverAddr: operatorStateRetrieverAddr,
-		ServiceManager:             contractServiceManager,
-		RegistryCoordinator:        contractBlsRegistryCoordinator,
-		StakeRegistry:              contractStakeRegistry,
-		BlsApkRegistry:             contractBlsApkRegistry,
-		IndexRegistry:              contractIndexRegistry,
-		OperatorStateRetriever:     contractOperatorStateRetriever,
-	}, nil
-}
-
 // NewBindingsFromConfig creates a new instance of ContractBindings
 func NewBindingsFromConfig(
 	cfg Config,

diff --git a/chainio/clients/avsregistry/reader.go b/chainio/clients/avsregistry/reader.go
@@ -84,48 +84,6 @@ func NewReaderFromConfig(
 	), nil
 }
 
-// BuildAvsRegistryChainReader creates a new ChainReader
-// Deprecated: Use NewReaderFromConfig instead
-func BuildAvsRegistryChainReader(
-	registryCoordinatorAddr common.Address,
-	operatorStateRetrieverAddr common.Address,
-	ethClient eth.HttpBackend,
-	logger logging.Logger,
-) (*ChainReader, error) {
-	contractRegistryCoordinator, err := regcoord.NewContractRegistryCoordinator(registryCoordinatorAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create contractRegistryCoordinator", err)
-	}
-	blsApkRegistryAddr, err := contractRegistryCoordinator.BlsApkRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get blsApkRegistryAddr", err)
-	}
-	stakeRegistryAddr, err := contractRegistryCoordinator.StakeRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get stakeRegistryAddr", err)
-	}
-	contractStakeRegistry, err := stakeregistry.NewContractStakeRegistry(stakeRegistryAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create contractStakeRegistry", err)
-	}
-	contractOperatorStateRetriever, err := opstateretriever.NewContractOperatorStateRetriever(
-		operatorStateRetrieverAddr,
-		ethClient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create contractOperatorStateRetriever", err)
-	}
-	return NewChainReader(
-		registryCoordinatorAddr,
-		blsApkRegistryAddr,
-		contractRegistryCoordinator,
-		contractOperatorStateRetriever,
-		contractStakeRegistry,
-		logger,
-		ethClient,
-	), nil
-}
-
 func (r *ChainReader) GetQuorumCount(opts *bind.CallOpts) (uint8, error) {
 	if r.registryCoordinator == nil {
 		return 0, errors.New("RegistryCoordinator contract not provided")

diff --git a/chainio/clients/avsregistry/subscriber.go b/chainio/clients/avsregistry/subscriber.go
@@ -2,7 +2,6 @@ package avsregistry
 
 import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/event"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
@@ -34,28 +33,6 @@ func NewChainSubscriber(
 	}
 }
 
-// BuildAvsRegistryChainSubscriber creates a new instance of ChainSubscriber
-// Deprecated: Use NewSubscriberFromConfig instead
-func BuildAvsRegistryChainSubscriber(
-	regCoordAddr common.Address,
-	ethWsClient eth.WsBackend,
-	logger logging.Logger,
-) (*ChainSubscriber, error) {
-	regCoord, err := regcoord.NewContractRegistryCoordinator(regCoordAddr, ethWsClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create RegistryCoordinator contract", err)
-	}
-	blsApkRegAddr, err := regCoord.BlsApkRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get BLSApkRegistry address from RegistryCoordinator", err)
-	}
-	blsApkReg, err := blsapkreg.NewContractBLSApkRegistry(blsApkRegAddr, ethWsClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create BLSApkRegistry contract", err)
-	}
-	return NewChainSubscriber(regCoord, blsApkReg, logger), nil
-}
-
 // NewSubscriberFromConfig creates a new instance of ChainSubscriber
 // A websocket ETH Client must be provided
 func NewSubscriberFromConfig(

diff --git a/chainio/clients/avsregistry/writer.go b/chainio/clients/avsregistry/writer.go
@@ -19,12 +19,10 @@ import (
 	blsapkregistry "github.com/Layr-Labs/eigensdk-go/contracts/bindings/BLSApkRegistry"
 	opstateretriever "github.com/Layr-Labs/eigensdk-go/contracts/bindings/OperatorStateRetriever"
 	regcoord "github.com/Layr-Labs/eigensdk-go/contracts/bindings/RegistryCoordinator"
-	smbase "github.com/Layr-Labs/eigensdk-go/contracts/bindings/ServiceManagerBase"
 	stakeregistry "github.com/Layr-Labs/eigensdk-go/contracts/bindings/StakeRegistry"
 	"github.com/Layr-Labs/eigensdk-go/crypto/bls"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/types"
-	"github.com/Layr-Labs/eigensdk-go/utils"
 )
 
 type eLReader interface {
@@ -75,75 +73,6 @@ func NewChainWriter(
 	}
 }
 
-// BuildAvsRegistryChainWriter creates a new ChainWriter instance from the provided contract addresses
-// Deprecated: Use NewWriterFromConfig instead
-func BuildAvsRegistryChainWriter(
-	registryCoordinatorAddr gethcommon.Address,
-	operatorStateRetrieverAddr gethcommon.Address,
-	logger logging.Logger,
-	ethClient eth.HttpBackend,
-	txMgr txmgr.TxManager,
-) (*ChainWriter, error) {
-	registryCoordinator, err := regcoord.NewContractRegistryCoordinator(registryCoordinatorAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create RegistryCoordinator contract", err)
-	}
-	operatorStateRetriever, err := opstateretriever.NewContractOperatorStateRetriever(
-		operatorStateRetrieverAddr,
-		ethClient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create OperatorStateRetriever contract", err)
-	}
-	serviceManagerAddr, err := registryCoordinator.ServiceManager(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get ServiceManager address", err)
-	}
-	serviceManager, err := smbase.NewContractServiceManagerBase(serviceManagerAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create ServiceManager contract", err)
-	}
-	blsApkRegistryAddr, err := registryCoordinator.BlsApkRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get BLSApkRegistry address", err)
-	}
-	blsApkRegistry, err := blsapkregistry.NewContractBLSApkRegistry(blsApkRegistryAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create BLSApkRegistry contract", err)
-	}
-	stakeRegistryAddr, err := registryCoordinator.StakeRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get StakeRegistry address", err)
-	}
-	stakeRegistry, err := stakeregistry.NewContractStakeRegistry(stakeRegistryAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create StakeRegistry contract", err)
-	}
-	delegationManagerAddr, err := stakeRegistry.Delegation(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get DelegationManager address", err)
-	}
-	avsDirectoryAddr, err := serviceManager.AvsDirectory(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get AvsDirectory address", err)
-	}
-	elReader, err := elcontracts.BuildELChainReader(delegationManagerAddr, avsDirectoryAddr, ethClient, logger)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create ELChainReader", err)
-	}
-	return NewChainWriter(
-		serviceManagerAddr,
-		registryCoordinator,
-		operatorStateRetriever,
-		stakeRegistry,
-		blsApkRegistry,
-		elReader,
-		logger,
-		ethClient,
-		txMgr,
-	), nil
-}
-
 // NewWriterFromConfig creates a new ChainWriter from the provided config
 func NewWriterFromConfig(
 	cfg Config,

diff --git a/chainio/clients/elcontracts/bindings.go b/chainio/clients/elcontracts/bindings.go
@@ -127,40 +127,3 @@ func NewBindingsFromConfig(
 func isZeroAddress(address gethcommon.Address) bool {
 	return address == gethcommon.Address{}
 }
-
-// NewEigenlayerContractBindings creates a new ContractBindings struct with the provided contract addresses
-// Deprecated: Use NewBindingsFromConfig instead
-func NewEigenlayerContractBindings(
-	delegationManagerAddr gethcommon.Address,
-	avsDirectoryAddr gethcommon.Address,
-	ethclient eth.HttpBackend,
-	logger logging.Logger,
-) (*ContractBindings, error) {
-	contractDelegationManager, err := delegationmanager.NewContractDelegationManager(delegationManagerAddr, ethclient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create DelegationManager contract", err)
-	}
-
-	strategyManagerAddr, err := contractDelegationManager.StrategyManager(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch StrategyManager address", err)
-	}
-	contractStrategyManager, err := strategymanager.NewContractStrategyManager(strategyManagerAddr, ethclient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch StrategyManager contract", err)
-	}
-
-	avsDirectory, err := avsdirectory.NewContractAVSDirectory(avsDirectoryAddr, ethclient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch AVSDirectory contract", err)
-	}
-
-	return &ContractBindings{
-		StrategyManagerAddr:   strategyManagerAddr,
-		DelegationManagerAddr: delegationManagerAddr,
-		AvsDirectoryAddr:      avsDirectoryAddr,
-		StrategyManager:       contractStrategyManager,
-		DelegationManager:     contractDelegationManager,
-		AvsDirectory:          avsDirectory,
-	}, nil
-}
diff --git a/chainio/clients/elcontracts/reader.go b/chainio/clients/elcontracts/reader.go
@@ -66,35 +66,6 @@ func NewChainReader(
 	}
 }
 
-// BuildELChainReader creates a new ELChainReader
-// Deprecated: Use BuildFromConfig instead
-func BuildELChainReader(
-	delegationManagerAddr gethcommon.Address,
-	avsDirectoryAddr gethcommon.Address,
-	ethClient eth.HttpBackend,
-	logger logging.Logger,
-) (*ChainReader, error) {
-	elContractBindings, err := NewEigenlayerContractBindings(
-		delegationManagerAddr,
-		avsDirectoryAddr,
-		ethClient,
-		logger,
-	)
-	if err != nil {
-		return nil, err
-	}
-	return NewChainReader(
-		elContractBindings.DelegationManager,
-		elContractBindings.StrategyManager,
-		elContractBindings.AvsDirectory,
-		elContractBindings.RewardsCoordinator,
-		elContractBindings.AllocationManager,
-		elContractBindings.PermissionController,
-		logger,
-		ethClient,
-	), nil
-}
-
 func NewReaderFromConfig(
 	cfg Config,
 	ethClient eth.HttpBackend,

diff --git a/chainio/clients/elcontracts/writer.go b/chainio/clients/elcontracts/writer.go
@@ -78,51 +78,6 @@ func NewChainWriter(
 	}
 }
 
-// BuildELChainWriter builds an ChainWriter instance.
-// Deprecated: Use NewWriterFromConfig instead.
-func BuildELChainWriter(
-	delegationManagerAddr gethcommon.Address,
-	avsDirectoryAddr gethcommon.Address,
-	ethClient eth.HttpBackend,
-	logger logging.Logger,
-	eigenMetrics metrics.Metrics,
-	txMgr txmgr.TxManager,
-) (*ChainWriter, error) {
-	elContractBindings, err := NewEigenlayerContractBindings(
-		delegationManagerAddr,
-		avsDirectoryAddr,
-		ethClient,
-		logger,
-	)
-	if err != nil {
-		return nil, err
-	}
-	elChainReader := NewChainReader(
-		elContractBindings.DelegationManager,
-		elContractBindings.StrategyManager,
-		elContractBindings.AvsDirectory,
-		elContractBindings.RewardsCoordinator,
-		elContractBindings.AllocationManager,
-		elContractBindings.PermissionController,
-		logger,
-		ethClient,
-	)
-	return NewChainWriter(
-		elContractBindings.DelegationManager,
-		elContractBindings.StrategyManager,
-		elContractBindings.RewardsCoordinator,
-		elContractBindings.AvsDirectory,
-		elContractBindings.AllocationManager,
-		elContractBindings.PermissionController,
-		elContractBindings.StrategyManagerAddr,
-		elChainReader,
-		ethClient,
-		logger,
-		eigenMetrics,
-		txMgr,
-	), nil
-}
-
 func NewWriterFromConfig(
 	cfg Config,
 	ethClient eth.HttpBackend,