feat: integrate address directory to eth reader

- Add NewReaderWithAddressDirectory() for address directory-based initialization
- ContractNames constants matching AddressDirectoryConstants.sol
- optional AddressDirectoryFlag, BlsOperatorStateRetrieverFlag, and EigenDAServiceManagerFlag
- validation to require either address directory OR both legacy flags
- backward compatibility for existing deployments without address directory

Author: hopeyen

api/clients/v2/examples/client_construction.go

@@ -28,10 +28,12 @@ import (
 // These constants are specific to the EigenDA holesky testnet. To execute the provided examples on a different
 // network, you will need to set these constants to the correct values, based on the chosen network.
 const (
-	ethRPCURL                        = "https://ethereum-holesky-rpc.publicnode.com"
-	disperserHostname                = "disperser-testnet-holesky.eigenda.xyz"
-	certVerifierRouterAddress        = "0x7F40A8e1B62aa1c8Afed23f6E8bAe0D340A4BC4e"
-	registryCoordinatorAddress       = "0x53012C69A189cfA2D9d29eb6F19B32e0A2EA3490"
+	ethRPCURL                  = "https://ethereum-holesky-rpc.publicnode.com"
+	disperserHostname          = "disperser-testnet-holesky.eigenda.xyz"
+	certVerifierRouterAddress  = "0x7F40A8e1B62aa1c8Afed23f6E8bAe0D340A4BC4e"
+	registryCoordinatorAddress = "0x53012C69A189cfA2D9d29eb6F19B32e0A2EA3490"
+	addressDirectoryAddress    = "0x0000000000000000000000000000000000000000" // TODO: Replace with actual EigenDADirectory address when deployed
+	// Legacy addresses (use addressDirectoryAddress instead when available)
 	blsOperatorStateRetrieverAddress = "0x003497Dd77E5B73C40e8aCbB562C8bb0410320E7"
 	eigenDAServiceManagerAddress     = "0xD4A7E1Bd8015057293f0D0A557088c286942e84b"
 )
@@ -329,14 +331,24 @@ func createKzgConfig() kzg.KzgConfig {
 }
 
 func createEthReader(logger logging.Logger, ethClient common.EthClient) (*eth.Reader, error) {
+	// Prefer address directory when available
+	if addressDirectoryAddress != "0x0000000000000000000000000000000000000000" {
+		ethReader, err := eth.NewReaderWithAddressDirectory(logger, ethClient, addressDirectoryAddress)
+		if err != nil {
+			return nil, fmt.Errorf("new reader with address directory: %w", err)
+		}
+		return ethReader, nil
+	}
+
+	// Fallback to legacy approach
 	ethReader, err := eth.NewReader(
 		logger,
 		ethClient,
 		blsOperatorStateRetrieverAddress,
 		eigenDAServiceManagerAddress,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("new reader: %w", err)
+		return nil, fmt.Errorf("new reader legacy: %w", err)
 	}
 
 	return ethReader, nil

contracts/bindings/EigenDADirectory/binding.go

@@ -49,7 +49,8 @@ contracts="PaymentVault \
   EigenDAThresholdRegistry \
   EigenDARelayRegistry \
   IEigenDARelayRegistry \
-  EigenDADisperserRegistry"
+  EigenDADisperserRegistry \
+  EigenDADirectory"
 
 for contract in $contracts; do
   create_binding_abi_only ./ $contract ./bindings

contracts/compile.sh

@@ -189,6 +189,7 @@ contract SetupEigenDA is EigenDADeployer, EigenLayerUtils {
         }
 
         string memory output = "eigenDA deployment output";
+        vm.serializeAddress(output, "eigenDADirectory", address(eigenDADirectory));
         vm.serializeAddress(output, "eigenDAServiceManager", address(eigenDAServiceManager));
         vm.serializeAddress(output, "operatorStateRetriever", address(operatorStateRetriever));
         vm.serializeAddress(output, "blsApkRegistry", address(apkRegistry));

contracts/script/SetUpEigenDA.s.sol

@@ -8,10 +8,14 @@ import (
 	"math/big"
 	"strings"
 
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/crypto"
+
 	"github.com/Layr-Labs/eigenda/common"
 	avsdir "github.com/Layr-Labs/eigenda/contracts/bindings/AVSDirectory"
 	blsapkreg "github.com/Layr-Labs/eigenda/contracts/bindings/BLSApkRegistry"
 	delegationmgr "github.com/Layr-Labs/eigenda/contracts/bindings/DelegationManager"
+	eigendadirectory "github.com/Layr-Labs/eigenda/contracts/bindings/EigenDADirectory"
 	disperserreg "github.com/Layr-Labs/eigenda/contracts/bindings/EigenDADisperserRegistry"
 	relayreg "github.com/Layr-Labs/eigenda/contracts/bindings/EigenDARelayRegistry"
 	eigendasrvmg "github.com/Layr-Labs/eigenda/contracts/bindings/EigenDAServiceManager"
@@ -25,10 +29,8 @@ import (
 	stakereg "github.com/Layr-Labs/eigenda/contracts/bindings/StakeRegistry"
 	"github.com/Layr-Labs/eigenda/core"
 	"github.com/Layr-Labs/eigensdk-go/logging"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	gethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/pingcap/errors"
 
 	blssigner "github.com/Layr-Labs/eigensdk-go/signer/bls"
@@ -52,6 +54,7 @@ type ContractBindings struct {
 	RelayRegistry         *relayreg.ContractEigenDARelayRegistry
 	ThresholdRegistry     *thresholdreg.ContractEigenDAThresholdRegistry
 	DisperserRegistry     *disperserreg.ContractEigenDADisperserRegistry
+	AddressDirectory      *eigendadirectory.ContractEigenDADirectory
 }
 
 type Reader struct {
@@ -80,6 +83,44 @@ func NewReader(
 	return e, err
 }
 
+// NewReaderWithAddressDirectory creates a new Reader using an address directory contract address
+func NewReaderWithAddressDirectory(
+	logger logging.Logger,
+	client common.EthClient,
+	addressDirectoryHexAddr string) (*Reader, error) {
+
+	e := &Reader{
+		ethClient: client,
+		logger:    logger.With("component", "Reader"),
+	}
+
+	addressDirectoryAddr := gethcommon.HexToAddress(addressDirectoryHexAddr)
+	addressDirectory, err := eigendadirectory.NewContractEigenDADirectory(addressDirectoryAddr, client)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch EigenDADirectory contract: %w", err)
+	}
+
+	// Convert contract names to keccak256 hashes as expected by the contract
+	operatorStateRetrieverKey := crypto.Keccak256Hash([]byte(ContractNames.OperatorStateRetriever))
+	blsOperatorStateRetrieverAddr, err := addressDirectory.GetAddress(&bind.CallOpts{}, operatorStateRetrieverKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get operator state retriever address: %w", err)
+	}
+
+	serviceManagerKey := crypto.Keccak256Hash([]byte(ContractNames.ServiceManager))
+	eigenDAServiceManagerAddr, err := addressDirectory.GetAddress(&bind.CallOpts{}, serviceManagerKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get service manager address: %w", err)
+	}
+	err = e.updateContractBindings(blsOperatorStateRetrieverAddr, eigenDAServiceManagerAddr)
+	if err != nil {
+		return nil, fmt.Errorf("failed to update contract bindings: %w", err)
+	}
+	return e, nil
+}
+
+// updateContractBindings updates the contract bindings for the reader
+// TODO: move to use address directory contract once all contracts are written into the directory
 func (t *Reader) updateContractBindings(blsOperatorStateRetrieverAddr, eigenDAServiceManagerAddr gethcommon.Address) error {
 
 	contractEigenDAServiceManager, err := eigendasrvmg.NewContractEigenDAServiceManager(eigenDAServiceManagerAddr, t.ethClient)

core/eth/reader.go

@@ -1,6 +1,7 @@
 package eth
 
 import (
+	"fmt"
 	"math/big"
 	"slices"
 
@@ -10,6 +11,7 @@ import (
 	eigendasrvmg "github.com/Layr-Labs/eigenda/contracts/bindings/EigenDAServiceManager"
 	paymentvault "github.com/Layr-Labs/eigenda/contracts/bindings/PaymentVault"
 
+	gethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
@@ -176,3 +178,56 @@ func GetAllQuorumIDs(quorumCount uint8) []core.QuorumID {
 	}
 	return quorumIDs
 }
+
+// ContractNames defines the standard contract names used in the address directory
+// TODO: consider auto-generating this from the address directory contract
+// These values must match exactly the constants defined in AddressDirectoryConstants.sol.
+var ContractNames = struct {
+	ServiceManager         string
+	OperatorStateRetriever string
+	RegistryCoordinator    string
+	BLSApkRegistry         string
+	IndexRegistry          string
+	StakeRegistry          string
+	SocketRegistry         string
+	PaymentVault           string
+	EjectionManager        string
+	RelayRegistry          string
+	ThresholdRegistry      string
+	DisperserRegistry      string
+}{
+	ServiceManager:         "SERVICE_MANAGER",
+	OperatorStateRetriever: "OPERATOR_STATE_RETRIEVER",
+	RegistryCoordinator:    "REGISTRY_COORDINATOR",
+	BLSApkRegistry:         "BLS_APK_REGISTRY",
+	IndexRegistry:          "INDEX_REGISTRY",
+	StakeRegistry:          "STAKE_REGISTRY",
+	SocketRegistry:         "SOCKET_REGISTRY",
+	PaymentVault:           "PAYMENT_VAULT",
+	EjectionManager:        "EJECTION_MANAGER",
+	RelayRegistry:          "RELAY_REGISTRY",
+	ThresholdRegistry:      "THRESHOLD_REGISTRY",
+	DisperserRegistry:      "DISPERSER_REGISTRY",
+}
+
+// ValidateAddressConfig validates that either address directory is provided OR both individual addresses are provided
+// and that all provided addresses are valid hex addresses.
+func ValidateAddressConfig(addressDirectory, blsOperatorStateRetriever, eigenDAServiceManager string) error {
+	// Validate that either address directory is provided OR both individual addresses are provided
+	if addressDirectory == "" && (blsOperatorStateRetriever == "" || eigenDAServiceManager == "") {
+		return fmt.Errorf("either address-directory must be provided, or both bls-operator-state-retriever and eigenda-service-manager addresses must be provided")
+	}
+
+	// Validate address formats
+	if addressDirectory != "" && !gethcommon.IsHexAddress(addressDirectory) {
+		return fmt.Errorf("address-directory must be a valid hex address")
+	}
+	if blsOperatorStateRetriever != "" && !gethcommon.IsHexAddress(blsOperatorStateRetriever) {
+		return fmt.Errorf("bls-operator-state-retriever must be a valid hex address")
+	}
+	if eigenDAServiceManager != "" && !gethcommon.IsHexAddress(eigenDAServiceManager) {
+		return fmt.Errorf("eigenda-service-manager must be a valid hex address")
+	}
+
+	return nil
+}

core/eth/utils.go

@@ -34,6 +34,7 @@ type Writer struct {
 
 var _ core.Writer = (*Writer)(nil)
 
+// NewWriter creates a new Writer using individual contract addresses (deprecated, use NewWriter instead)
 func NewWriter(
 	logger logging.Logger,
 	client common.EthClient,
@@ -58,6 +59,26 @@ func NewWriter(
 	return e, err
 }
 
+// NewWriterWithAddressDirectory creates a new Writer using an address directory contract address
+func NewWriterWithAddressDirectory(
+	logger logging.Logger,
+	client common.EthClient,
+	addressDirectoryHexAddr string) (*Writer, error) {
+
+	r, err := NewReaderWithAddressDirectory(logger, client, addressDirectoryHexAddr)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create reader with address directory: %w", err)
+	}
+
+	e := &Writer{
+		ethClient: client,
+		logger:    logger.With("component", "Writer"),
+		Reader:    r,
+	}
+
+	return e, nil
+}
+
 // RegisterOperator registers a new operator with the given public key and socket with the provided quorum ids.
 // If the operator is already registered with a given quorum id, the transaction will fail (noop) and an error
 // will be returned.

core/eth/writer.go

@@ -46,16 +46,22 @@ var (
 		EnvVar:   common.PrefixEnvVar(envVarPrefix, "GRPC_STREAM_TIMEOUT"),
 		Value:    time.Second * 10,
 	}
+	AddressDirectoryFlag = cli.StringFlag{
+		Name:     common.PrefixFlag(FlagPrefix, "address-directory"),
+		Usage:    "Address of the EigenDA Directory contract (preferred over individual contract addresses)",
+		Required: false,
+		EnvVar:   common.PrefixEnvVar(envVarPrefix, "ADDRESS_DIRECTORY"),
+	}
 	BlsOperatorStateRetrieverFlag = cli.StringFlag{
 		Name:     common.PrefixFlag(FlagPrefix, "bls-operator-state-retriever"),
 		Usage:    "Address of the BLS Operator State Retriever",
-		Required: true,
-		EnvVar:   common.PrefixEnvVar(envVarPrefix, "BLS_OPERATOR_STATE_RETRIVER"),
+		Required: false,
+		EnvVar:   common.PrefixEnvVar(envVarPrefix, "BLS_OPERATOR_STATE_RETRIEVER"),
 	}
 	EigenDAServiceManagerFlag = cli.StringFlag{
 		Name:     common.PrefixFlag(FlagPrefix, "eigenda-service-manager"),
 		Usage:    "Address of the EigenDA Service Manager",
-		Required: true,
+		Required: false,
 		EnvVar:   common.PrefixEnvVar(envVarPrefix, "EIGENDA_SERVICE_MANAGER"),
 	}
 	/* Optional Flags*/
@@ -270,8 +276,6 @@ var requiredFlags = []cli.Flag{
 	DynamoDBTableNameFlag,
 	GrpcPortFlag,
 	BucketTableName,
-	BlsOperatorStateRetrieverFlag,
-	EigenDAServiceManagerFlag,
 }
 
 var optionalFlags = []cli.Flag{
@@ -295,6 +299,9 @@ var optionalFlags = []cli.Flag{
 	NtpServerFlag,
 	NtpSyncIntervalFlag,
 	ReservedOnly,
+	AddressDirectoryFlag,
+	BlsOperatorStateRetrieverFlag,
+	EigenDAServiceManagerFlag,
 }
 
 // Flags contains the list of configuration options available to the binary.

disperser/cmd/apiserver/flags/flags.go

@@ -52,7 +52,12 @@ func RunDisperserServer(ctx *cli.Context) error {
 		return err
 	}
 
-	transactor, err := eth.NewReader(logger, client, config.BLSOperatorStateRetrieverAddr, config.EigenDAServiceManagerAddr)
+	var transactor *eth.Reader
+	if config.AddressDirectoryAddr != "" {
+		transactor, err = eth.NewReaderWithAddressDirectory(logger, client, config.AddressDirectoryAddr)
+	} else {
+		transactor, err = eth.NewReader(logger, client, config.BLSOperatorStateRetrieverAddr, config.EigenDAServiceManagerAddr)
+	}
 	if err != nil {
 		return err
 	}

disperser/cmd/apiserver/lib/apiserver.go

@@ -13,6 +13,7 @@ import (
 	"github.com/Layr-Labs/eigenda/disperser/cmd/apiserver/flags"
 	"github.com/Layr-Labs/eigenda/disperser/common/blobstore"
 	"github.com/Layr-Labs/eigenda/encoding/kzg"
+	gethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/urfave/cli"
 )
 
@@ -47,6 +48,7 @@ type Config struct {
 	MaxNumSymbolsPerBlob        uint
 	OnchainStateRefreshInterval time.Duration
 
+	AddressDirectoryAddr            string
 	BLSOperatorStateRetrieverAddr   string
 	EigenDAServiceManagerAddr       string
 	AuthPmtStateRequestMaxPastAge   time.Duration
@@ -96,6 +98,26 @@ func NewConfig(ctx *cli.Context) (Config, error) {
 		}
 	}
 
+	// Validate that either address directory is provided OR both individual addresses are provided
+	addressDirectoryAddr := ctx.GlobalString(flags.AddressDirectoryFlag.Name)
+	blsOperatorStateRetrieverAddr := ctx.GlobalString(flags.BlsOperatorStateRetrieverFlag.Name)
+	eigenDAServiceManagerAddr := ctx.GlobalString(flags.EigenDAServiceManagerFlag.Name)
+
+	if addressDirectoryAddr == "" && (blsOperatorStateRetrieverAddr == "" || eigenDAServiceManagerAddr == "") {
+		return Config{}, fmt.Errorf("either address-directory must be provided, or both bls-operator-state-retriever and eigenda-service-manager addresses must be provided")
+	}
+
+	// Validate address formats
+	if addressDirectoryAddr != "" && !gethcommon.IsHexAddress(addressDirectoryAddr) {
+		return Config{}, fmt.Errorf("address-directory must be a valid hex address")
+	}
+	if blsOperatorStateRetrieverAddr != "" && !gethcommon.IsHexAddress(blsOperatorStateRetrieverAddr) {
+		return Config{}, fmt.Errorf("bls-operator-state-retriever must be a valid hex address")
+	}
+	if eigenDAServiceManagerAddr != "" && !gethcommon.IsHexAddress(eigenDAServiceManagerAddr) {
+		return Config{}, fmt.Errorf("eigenda-service-manager must be a valid hex address")
+	}
+
 	config := Config{
 		DisperserVersion: DisperserVersion(version),
 		AwsClientConfig:  aws.ReadClientConfig(ctx, flags.FlagPrefix),
@@ -131,8 +153,9 @@ func NewConfig(ctx *cli.Context) (Config, error) {
 		MaxNumSymbolsPerBlob:        ctx.GlobalUint(flags.MaxNumSymbolsPerBlob.Name),
 		OnchainStateRefreshInterval: ctx.GlobalDuration(flags.OnchainStateRefreshInterval.Name),
 
-		BLSOperatorStateRetrieverAddr:   ctx.GlobalString(flags.BlsOperatorStateRetrieverFlag.Name),
-		EigenDAServiceManagerAddr:       ctx.GlobalString(flags.EigenDAServiceManagerFlag.Name),
+		AddressDirectoryAddr:            addressDirectoryAddr,
+		BLSOperatorStateRetrieverAddr:   blsOperatorStateRetrieverAddr,
+		EigenDAServiceManagerAddr:       eigenDAServiceManagerAddr,
 		AuthPmtStateRequestMaxPastAge:   ctx.GlobalDuration(flags.AuthPmtStateRequestMaxPastAge.Name),
 		AuthPmtStateRequestMaxFutureAge: ctx.GlobalDuration(flags.AuthPmtStateRequestMaxFutureAge.Name),
 		NtpServer:                       ctx.GlobalString(flags.NtpServerFlag.Name),