refactor(EigenDADirectory): rename more address directory to eigenda directory

Author: hopeyen

api/clients/v2/examples/client_construction.go

@@ -32,7 +32,7 @@ const (
 	disperserHostname = "disperser-testnet-holesky.eigenda.xyz"
 
 	// Eth client
-	addressDirectoryAddress = "0x90776Ea0E99E4c38aA1Efe575a61B3E40160A2FE"
+	eigendaDirectoryAddress = "0x90776Ea0E99E4c38aA1Efe575a61B3E40160A2FE"
 
 	// Router address provider
 	certVerifierRouterAddress = "0x7F40A8e1B62aa1c8Afed23f6E8bAe0D340A4BC4e"
@@ -338,7 +338,7 @@ func createEthReader(logger logging.Logger, ethClient common.EthClient) (*eth.Re
 	ethReader, err := eth.NewReader(
 		logger,
 		ethClient,
-		addressDirectoryAddress,
+		eigendaDirectoryAddress,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("new reader: %w", err)

core/eth/address_directory_reader.go renamed to core/eth/eigenda_directory_reader.go

@@ -10,32 +10,32 @@ import (
 	gethcommon "github.com/ethereum/go-ethereum/common"
 )
 
-// AddressDirectoryReader wraps the address directory contract and provides
+// EigenDADirectoryReader wraps the address directory contract and provides
 // safe getters for contract addresses with zero address validation
-type AddressDirectoryReader struct {
+type EigenDADirectoryReader struct {
 	contract *eigendadirectory.ContractIEigenDADirectory
 }
 
-// NewAddressDirectoryReader creates a new AddressDirectoryReader
-func NewAddressDirectoryReader(addressDirectoryHexAddr string, client common.EthClient) (*AddressDirectoryReader, error) {
-	if addressDirectoryHexAddr == "" || !gethcommon.IsHexAddress(addressDirectoryHexAddr) {
-		return nil, fmt.Errorf("address directory must be a valid hex address: %s", addressDirectoryHexAddr)
+// NewEigenDADirectoryReader creates a new EigenDADirectoryReader
+func NewEigenDADirectoryReader(eigendaDirectoryHexAddr string, client common.EthClient) (*EigenDADirectoryReader, error) {
+	if eigendaDirectoryHexAddr == "" || !gethcommon.IsHexAddress(eigendaDirectoryHexAddr) {
+		return nil, fmt.Errorf("address directory must be a valid hex address: %s", eigendaDirectoryHexAddr)
 	}
 
-	addressDirectoryAddr := gethcommon.HexToAddress(addressDirectoryHexAddr)
-	contract, err := eigendadirectory.NewContractIEigenDADirectory(addressDirectoryAddr, client)
+	eigendaDirectoryAddr := gethcommon.HexToAddress(eigendaDirectoryHexAddr)
+	contract, err := eigendadirectory.NewContractIEigenDADirectory(eigendaDirectoryAddr, client)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create EigenDADirectory contract: %w", err)
 	}
 
-	return &AddressDirectoryReader{
+	return &EigenDADirectoryReader{
 		contract: contract,
 	}, nil
 }
 
 // getAddressWithValidation reads the directory to get an address by the contract name
 // and validates it's not zero
-func (r *AddressDirectoryReader) getAddressWithValidation(contractName string) (gethcommon.Address, error) {
+func (r *EigenDADirectoryReader) getAddressWithValidation(contractName string) (gethcommon.Address, error) {
 	names, err := r.contract.GetAllNames(&bind.CallOpts{})
 	if err != nil {
 		return gethcommon.Address{}, fmt.Errorf("failed to get all contract names: %w", err)
@@ -55,12 +55,12 @@ func (r *AddressDirectoryReader) getAddressWithValidation(contractName string) (
 }
 
 // GetOperatorStateRetrieverAddress returns the operator state retriever address with validation
-func (r *AddressDirectoryReader) GetOperatorStateRetrieverAddress() (gethcommon.Address, error) {
+func (r *EigenDADirectoryReader) GetOperatorStateRetrieverAddress() (gethcommon.Address, error) {
 	return r.getAddressWithValidation(ContractNames.OperatorStateRetriever)
 }
 
 // GetServiceManagerAddress returns the service manager address with validation
-func (r *AddressDirectoryReader) GetServiceManagerAddress() (gethcommon.Address, error) {
+func (r *EigenDADirectoryReader) GetServiceManagerAddress() (gethcommon.Address, error) {
 	return r.getAddressWithValidation(ContractNames.ServiceManager)
 }
 

core/eth/reader.go

@@ -68,14 +68,14 @@ var _ core.Reader = (*Reader)(nil)
 func NewReader(
 	logger logging.Logger,
 	client common.EthClient,
-	addressDirectoryHexAddr string) (*Reader, error) {
+	eigendaDirectoryHexAddr string) (*Reader, error) {
 
 	e := &Reader{
 		ethClient: client,
 		logger:    logger.With("component", "Reader"),
 	}
 
-	addressReader, err := NewAddressDirectoryReader(addressDirectoryHexAddr, client)
+	addressReader, err := NewEigenDADirectoryReader(eigendaDirectoryHexAddr, client)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create address directory reader: %w", err)
 	}

core/eth/writer.go

@@ -37,9 +37,9 @@ var _ core.Writer = (*Writer)(nil)
 func NewWriter(
 	logger logging.Logger,
 	client common.EthClient,
-	addressDirectoryHexAddr string) (*Writer, error) {
+	eigendaDirectoryHexAddr string) (*Writer, error) {
 
-	r, err := NewReader(logger, client, addressDirectoryHexAddr)
+	r, err := NewReader(logger, client, eigendaDirectoryHexAddr)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create reader with address directory: %w", err)
 	}

node/node.go

@@ -209,7 +209,7 @@ func NewNode(
 	}
 
 	// Get service manager address from address directory
-	addressReader, err := eth.NewAddressDirectoryReader(config.EigenDADirectory, client)
+	addressReader, err := eth.NewEigenDADirectoryReader(config.EigenDADirectory, client)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create address directory reader: %w", err)
 	}