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

@@ -0,0 +1,59 @@
+package eth
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/Layr-Labs/eigenda/common"
+	gethcommon "github.com/ethereum/go-ethereum/common"
+)
+
+// AddressDirectoryClient provides access to the EigenDADirectory contract
+type AddressDirectoryClient struct {
+	directoryAddr gethcommon.Address
+	ethClient     common.EthClient
+}
+
+// NewAddressDirectoryClient creates a new AddressDirectoryClient
+func NewAddressDirectoryClient(directoryAddr gethcommon.Address, ethClient common.EthClient) *AddressDirectoryClient {
+	return &AddressDirectoryClient{
+		directoryAddr: directoryAddr,
+		ethClient:     ethClient,
+	}
+}
+
+// GetAddress retrieves an address by name from the directory
+func (a *AddressDirectoryClient) GetAddress(ctx context.Context, name string) (gethcommon.Address, error) {
+	// TODO: Replace this with actual contract call once bindings are available
+	// For now, return zero address to avoid compilation errors
+	return gethcommon.Address{}, fmt.Errorf("address directory client not fully implemented - need contract bindings")
+}
+
+// ContractNames defines the standard contract names used in the address directory
+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",
+}

core/eth/address_directory_client.go

@@ -0,0 +1,64 @@
+package examples
+
+import (
+	"context"
+
+	"github.com/Layr-Labs/eigenda/common"
+	"github.com/Layr-Labs/eigenda/core/eth"
+	"github.com/Layr-Labs/eigensdk-go/logging"
+)
+
+// ExampleAddressDirectoryUsage demonstrates how to use the new address directory integration
+func ExampleAddressDirectoryUsage() {
+	logger, _ := logging.NewZapLogger(logging.Development)
+	var ethClient common.EthClient // Initialize your eth client
+
+	// OLD WAY: Using individual contract addresses (now legacy)
+	// blsOperatorStateRetrieverAddr := "0x123..."
+	// eigenDAServiceManagerAddr := "0x456..."
+	// reader, err := eth.NewReader(logger, ethClient, blsOperatorStateRetrieverAddr, eigenDAServiceManagerAddr)
+	// writer, err := eth.NewWriterLegacy(logger, ethClient, blsOperatorStateRetrieverAddr, eigenDAServiceManagerAddr)
+
+	// NEW WAY: Using address directory (preferred)
+	addressDirectoryAddr := "0x789..." // The address of the deployed EigenDADirectory contract
+
+	// Create reader with address directory
+	reader, err := eth.NewReaderWithAddressDirectory(logger, ethClient, addressDirectoryAddr)
+	if err != nil {
+		panic(err)
+	}
+
+	// Create writer with address directory
+	writer, err := eth.NewWriterWithAddressDirectory(logger, ethClient, addressDirectoryAddr)
+	if err != nil {
+		panic(err)
+	}
+
+	// Use reader and writer as normal
+	ctx := context.Background()
+	blockNumber, err := reader.GetCurrentBlockNumber(ctx)
+	if err != nil {
+		panic(err)
+	}
+
+	// The reader and writer now automatically resolve contract addresses from the directory
+	_ = blockNumber
+	_ = writer
+}
+
+// AvailableContractNames shows the standard contract names available in the address directory
+func AvailableContractNames() {
+	// These contract names can be used with the address directory:
+	_ = eth.ContractNames.ServiceManager         // "SERVICE_MANAGER"
+	_ = eth.ContractNames.OperatorStateRetriever // "OPERATOR_STATE_RETRIEVER"
+	_ = eth.ContractNames.RegistryCoordinator    // "REGISTRY_COORDINATOR"
+	_ = eth.ContractNames.BLSApkRegistry         // "BLS_APK_REGISTRY"
+	_ = eth.ContractNames.IndexRegistry          // "INDEX_REGISTRY"
+	_ = eth.ContractNames.StakeRegistry          // "STAKE_REGISTRY"
+	_ = eth.ContractNames.SocketRegistry         // "SOCKET_REGISTRY"
+	_ = eth.ContractNames.PaymentVault           // "PAYMENT_VAULT"
+	_ = eth.ContractNames.EjectionManager        // "EJECTION_MANAGER"
+	_ = eth.ContractNames.RelayRegistry          // "RELAY_REGISTRY"
+	_ = eth.ContractNames.ThresholdRegistry      // "THRESHOLD_REGISTRY"
+	_ = eth.ContractNames.DisperserRegistry      // "DISPERSER_REGISTRY"
+}

core/eth/examples/address_directory_usage.go

@@ -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,42 @@ 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
+}
+
 func (t *Reader) updateContractBindings(blsOperatorStateRetrieverAddr, eigenDAServiceManagerAddr gethcommon.Address) error {
 
 	contractEigenDAServiceManager, err := eigendasrvmg.NewContractEigenDAServiceManager(eigenDAServiceManagerAddr, t.ethClient)

core/eth/reader.go

@@ -34,15 +34,16 @@ 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,
 	blsOperatorStateRetrieverHexAddr string,
 	eigenDAServiceManagerHexAddr string) (*Writer, error) {
 
-	r := &Reader{
-		ethClient: client,
-		logger:    logger.With("component", "Reader"),
+	r, err := NewReader(logger, client, blsOperatorStateRetrieverHexAddr, eigenDAServiceManagerHexAddr)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create reader with legacy addresses: %w", err)
 	}
 
 	e := &Writer{
@@ -51,11 +52,27 @@ func NewWriter(
 		Reader:    r,
 	}
 
-	blsOperatorStateRetrieverAddr := gethcommon.HexToAddress(blsOperatorStateRetrieverHexAddr)
-	eigenDAServiceManagerAddr := gethcommon.HexToAddress(eigenDAServiceManagerHexAddr)
-	err := e.updateContractBindings(blsOperatorStateRetrieverAddr, eigenDAServiceManagerAddr)
+	return e, nil
+}
+
+// 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, err
+	return e, nil
 }
 
 // RegisterOperator registers a new operator with the given public key and socket with the provided quorum ids.

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
 	}