feat: relax indexedChainState to ChainState for retrieval

api/clients/mock/node_client.go

@@ -46,7 +46,7 @@ func (c *MockNodeClient) GetBlobHeader(ctx context.Context, socket string, batch
 func (c *MockNodeClient) GetChunks(
 	ctx context.Context,
 	opID core.OperatorID,
-	opInfo *core.IndexedOperatorInfo,
+	opInfo *core.OperatorInfo,
 	batchHeaderHash [32]byte,
 	blobIndex uint32,
 	quorumID core.QuorumID,

api/clients/node_client.go

@@ -21,7 +21,7 @@ type RetrievedChunks struct {
 
 type NodeClient interface {
 	GetBlobHeader(ctx context.Context, socket string, batchHeaderHash [32]byte, blobIndex uint32) (*core.BlobHeader, *merkletree.Proof, error)
-	GetChunks(ctx context.Context, opID core.OperatorID, opInfo *core.IndexedOperatorInfo, batchHeaderHash [32]byte, blobIndex uint32, quorumID core.QuorumID, chunksChan chan RetrievedChunks)
+	GetChunks(ctx context.Context, opID core.OperatorID, opInfo *core.OperatorInfo, batchHeaderHash [32]byte, blobIndex uint32, quorumID core.QuorumID, chunksChan chan RetrievedChunks)
 }
 
 type client struct {
@@ -79,7 +79,7 @@ func (c client) GetBlobHeader(
 func (c client) GetChunks(
 	ctx context.Context,
 	opID core.OperatorID,
-	opInfo *core.IndexedOperatorInfo,
+	opInfo *core.OperatorInfo,
 	batchHeaderHash [32]byte,
 	blobIndex uint32,
 	quorumID core.QuorumID,

api/clients/retrieval_client.go

@@ -53,7 +53,7 @@ type BlobChunks struct {
 
 type retrievalClient struct {
 	logger                logging.Logger
-	indexedChainState     core.IndexedChainState
+	chainState            core.ChainState
 	assignmentCoordinator core.AssignmentCoordinator
 	nodeClient            NodeClient
 	verifier              encoding.Verifier
@@ -63,15 +63,15 @@ type retrievalClient struct {
 // NewRetrievalClient creates a new retrieval client.
 func NewRetrievalClient(
 	logger logging.Logger,
-	chainState core.IndexedChainState,
+	chainState core.ChainState,
 	assignmentCoordinator core.AssignmentCoordinator,
 	nodeClient NodeClient,
 	verifier encoding.Verifier,
 	numConnections int) (RetrievalClient, error) {
 
 	return &retrievalClient{
 		logger:                logger.With("component", "RetrievalClient"),
-		indexedChainState:     chainState,
+		chainState:            chainState,
 		assignmentCoordinator: assignmentCoordinator,
 		nodeClient:            nodeClient,
 		verifier:              verifier,
@@ -104,11 +104,11 @@ func (r *retrievalClient) RetrieveBlobChunks(ctx context.Context,
 	batchRoot [32]byte,
 	quorumID core.QuorumID) (*BlobChunks, error) {
 
-	indexedOperatorState, err := r.indexedChainState.GetIndexedOperatorState(ctx, referenceBlockNumber, []core.QuorumID{quorumID})
+	operatorState, err := r.chainState.GetOperatorState(ctx, referenceBlockNumber, []core.QuorumID{quorumID})
 	if err != nil {
 		return nil, err
 	}
-	operators, ok := indexedOperatorState.Operators[quorumID]
+	operators, ok := operatorState.Operators[quorumID]
 	if !ok {
 		return nil, fmt.Errorf("no quorum with ID: %d", quorumID)
 	}
@@ -118,7 +118,7 @@ func (r *retrievalClient) RetrieveBlobChunks(ctx context.Context,
 	var proof *merkletree.Proof
 	var proofVerified bool
 	for opID := range operators {
-		opInfo := indexedOperatorState.IndexedOperators[opID]
+		opInfo := operators[opID]
 		blobHeader, proof, err = r.nodeClient.GetBlobHeader(ctx, opInfo.Socket, batchHeaderHash, blobIndex)
 		if err != nil {
 			// try another operator
@@ -172,7 +172,7 @@ func (r *retrievalClient) RetrieveBlobChunks(ctx context.Context,
 		return nil, err
 	}
 
-	assignments, info, err := r.assignmentCoordinator.GetAssignments(indexedOperatorState.OperatorState, blobHeader.Length, quorumHeader)
+	assignments, info, err := r.assignmentCoordinator.GetAssignments(operatorState, blobHeader.Length, quorumHeader)
 	if err != nil {
 		return nil, errors.New("failed to get assignments")
 	}
@@ -182,7 +182,7 @@ func (r *retrievalClient) RetrieveBlobChunks(ctx context.Context,
 	pool := workerpool.New(r.numConnections)
 	for opID := range operators {
 		opID := opID
-		opInfo := indexedOperatorState.IndexedOperators[opID]
+		opInfo := operators[opID]
 		pool.Submit(func() {
 			r.nodeClient.GetChunks(ctx, opID, opInfo, batchHeaderHash, blobIndex, quorumID, chunksChan)
 		})

api/clients/retrieval_client_test.go

@@ -52,15 +52,14 @@ func makeTestComponents() (encoding.Prover, encoding.Verifier, error) {
 }
 
 var (
-	indexedChainState core.IndexedChainState
-	chainState        core.ChainState
-	indexer           *indexermock.MockIndexer
-	operatorState     *core.OperatorState
-	nodeClient        *clientsmock.MockNodeClient
-	coordinator       *core.StdAssignmentCoordinator
-	retrievalClient   clients.RetrievalClient
-	blobHeader        *core.BlobHeader
-	encodedBlob       core.EncodedBlob = core.EncodedBlob{
+	chainState      core.ChainState
+	indexer         *indexermock.MockIndexer
+	operatorState   *core.OperatorState
+	nodeClient      *clientsmock.MockNodeClient
+	coordinator     *core.StdAssignmentCoordinator
+	retrievalClient clients.RetrievalClient
+	blobHeader      *core.BlobHeader
+	encodedBlob     core.EncodedBlob = core.EncodedBlob{
 		BlobHeader:               nil,
 		EncodedBundlesByOperator: make(map[core.OperatorID]core.EncodedBundles),
 	}
@@ -81,15 +80,6 @@ func setup(t *testing.T) {
 		t.Fatalf("failed to create new mocked chain data: %s", err)
 	}
 
-	indexedChainState, err = coremock.MakeChainDataMock(map[uint8]int{
-		0: numOperators,
-		1: numOperators,
-		2: numOperators,
-	})
-	if err != nil {
-		t.Fatalf("failed to create new mocked indexed chain data: %s", err)
-	}
-
 	nodeClient = clientsmock.NewNodeClient()
 	coordinator = &core.StdAssignmentCoordinator{}
 	p, v, err := makeTestComponents()
@@ -100,12 +90,7 @@ func setup(t *testing.T) {
 	indexer = &indexermock.MockIndexer{}
 	indexer.On("Index").Return(nil).Once()
 
-	ics, err := coreindexer.NewIndexedChainState(chainState, indexer)
-	if err != nil {
-		panic("failed to create a new indexed chain state")
-	}
-
-	retrievalClient, err = clients.NewRetrievalClient(logger, ics, coordinator, nodeClient, v, 2)
+	retrievalClient, err = clients.NewRetrievalClient(logger, chainState, coordinator, nodeClient, v, 2)
 	if err != nil {
 		panic("failed to create a new retrieval client")
 	}
@@ -132,7 +117,7 @@ func setup(t *testing.T) {
 		},
 		Data: codec.ConvertByPaddingEmptyByte(gettysburgAddressBytes),
 	}
-	operatorState, err = indexedChainState.GetOperatorState(context.Background(), (0), []core.QuorumID{quorumID})
+	operatorState, err = chainState.GetOperatorState(context.Background(), (0), []core.QuorumID{quorumID})
 	if err != nil {
 		t.Fatalf("failed to get operator state: %s", err)
 	}

api/clients/v2/retrieval_client.go

@@ -33,11 +33,11 @@ type RetrievalClient interface {
 }
 
 type retrievalClient struct {
-	logger            logging.Logger
-	ethClient         core.Reader
-	indexedChainState core.IndexedChainState
-	verifier          encoding.Verifier
-	numConnections    int
+	logger         logging.Logger
+	ethClient      core.Reader
+	chainState     core.ChainState
+	verifier       encoding.Verifier
+	numConnections int
 }
 
 var _ RetrievalClient = &retrievalClient{}
@@ -46,16 +46,16 @@ var _ RetrievalClient = &retrievalClient{}
 func NewRetrievalClient(
 	logger logging.Logger,
 	ethClient core.Reader,
-	chainState core.IndexedChainState,
+	chainState core.ChainState,
 	verifier encoding.Verifier,
 	numConnections int,
 ) RetrievalClient {
 	return &retrievalClient{
-		logger:            logger.With("component", "RetrievalClient"),
-		ethClient:         ethClient,
-		indexedChainState: chainState,
-		verifier:          verifier,
-		numConnections:    numConnections,
+		logger:         logger.With("component", "RetrievalClient"),
+		ethClient:      ethClient,
+		chainState:     chainState,
+		verifier:       verifier,
+		numConnections: numConnections,
 	}
 }
 
@@ -74,11 +74,11 @@ func (r *retrievalClient) GetBlob(
 		return nil, err
 	}
 
-	indexedOperatorState, err := r.indexedChainState.GetIndexedOperatorState(ctx, uint(referenceBlockNumber), []core.QuorumID{quorumID})
+	operatorState, err := r.chainState.GetOperatorState(ctx, uint(referenceBlockNumber), []core.QuorumID{quorumID})
 	if err != nil {
 		return nil, err
 	}
-	operators, ok := indexedOperatorState.Operators[quorumID]
+	operators, ok := operatorState.Operators[quorumID]
 	if !ok {
 		return nil, fmt.Errorf("no quorum with ID: %d", quorumID)
 	}
@@ -98,7 +98,7 @@ func (r *retrievalClient) GetBlob(
 		return nil, err
 	}
 
-	assignments, err := corev2.GetAssignments(indexedOperatorState.OperatorState, blobParam, quorumID)
+	assignments, err := corev2.GetAssignments(operatorState, blobParam, quorumID)
 	if err != nil {
 		return nil, errors.New("failed to get assignments")
 	}
@@ -107,8 +107,7 @@ func (r *retrievalClient) GetBlob(
 	chunksChan := make(chan clients.RetrievedChunks, len(operators))
 	pool := workerpool.New(r.numConnections)
 	for opID := range operators {
-		opID := opID
-		opInfo := indexedOperatorState.IndexedOperators[opID]
+		opInfo := operators[opID]
 		pool.Submit(func() {
 			r.getChunksFromOperator(ctx, opID, opInfo, blobKey, quorumID, chunksChan)
 		})
@@ -160,7 +159,7 @@ func (r *retrievalClient) GetBlob(
 func (r *retrievalClient) getChunksFromOperator(
 	ctx context.Context,
 	opID core.OperatorID,
-	opInfo *core.IndexedOperatorInfo,
+	opInfo *core.OperatorInfo,
 	blobKey corev2.BlobKey,
 	quorumID core.QuorumID,
 	chunksChan chan clients.RetrievedChunks,

api/clients/v2/validator_payload_retriever.go

@@ -9,7 +9,6 @@ import (
 	"github.com/Layr-Labs/eigenda/common/geth"
 	"github.com/Layr-Labs/eigenda/core"
 	"github.com/Layr-Labs/eigenda/core/eth"
-	"github.com/Layr-Labs/eigenda/core/thegraph"
 	corev2 "github.com/Layr-Labs/eigenda/core/v2"
 	"github.com/Layr-Labs/eigenda/encoding"
 	"github.com/Layr-Labs/eigenda/encoding/kzg"
@@ -37,7 +36,6 @@ func BuildValidatorPayloadRetriever(
 	logger logging.Logger,
 	validatorPayloadRetrieverConfig ValidatorPayloadRetrieverConfig,
 	ethConfig geth.EthClientConfig,
-	thegraphConfig thegraph.Config,
 	kzgConfig kzg.KzgConfig,
 ) (*ValidatorPayloadRetriever, error) {
 	err := validatorPayloadRetrieverConfig.checkAndSetDefaults()
@@ -59,8 +57,10 @@ func BuildValidatorPayloadRetriever(
 		return nil, fmt.Errorf("new reader: %w", err)
 	}
 
-	chainState := eth.NewChainState(reader, ethClient)
-	indexedChainState := thegraph.MakeIndexedChainState(thegraphConfig, chainState, logger)
+	chainState, err := eth.NewChainState(reader, ethClient, logger)
+	if err != nil {
+		return nil, fmt.Errorf("new chain state: %w", err)
+	}
 
 	kzgVerifier, err := verifier.NewVerifier(&kzgConfig, nil)
 	if err != nil {
@@ -70,7 +70,7 @@ func BuildValidatorPayloadRetriever(
 	retrievalClient := NewRetrievalClient(
 		logger,
 		reader,
-		indexedChainState,
+		chainState,
 		kzgVerifier,
 		int(validatorPayloadRetrieverConfig.MaxConnectionCount))
 

common/abi.go

@@ -9,4 +9,11 @@ import (
 //go:embed abis/EigenDAServiceManager.json
 var ServiceManagerAbi []byte
 
+//go:embed abis/RegistryCoordinator.json
+var RegistryCoordinatorAbi []byte
+
 var BatchConfirmedEventSigHash = crypto.Keccak256Hash([]byte("BatchConfirmed(bytes32,uint32)"))
+var OperatorSocketUpdateEventSigHash = crypto.Keccak256Hash([]byte("OperatorSocketUpdate(bytes32,string)"))
+
+// TODO: consider adding deregistration for limiting size of socket map
+// var OperatorDeregisteredEventSigHash = crypto.Keccak256Hash([]byte("OperatorDeregistered(address,bytes32)"))