DAS protobuffs

api/proto/common/common.proto

@@ -3,8 +3,47 @@ package common;
 option go_package = "github.com/Layr-Labs/eigenda/api/grpc/common";
 
 message G1Commitment {
-	// The X coordinate of the KZG commitment. This is the raw byte representation of the field element.
-	bytes x = 1;
-	// The Y coordinate of the KZG commitment. This is the raw byte representation of the field element.
-	bytes y = 2;
+  // The X coordinate of the KZG commitment. This is the raw byte representation of the field element.
+  bytes x = 1;
+  // The Y coordinate of the KZG commitment. This is the raw byte representation of the field element.
+  bytes y = 2;
 }
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Messages for WIP RPCs. These are subject to change, do not consider these to be stable API. //
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+// A unique identifier for a blob.
+message BlobKey {
+  oneof key {
+    AuthHeaderBlobKey auth_header_blob_key = 1;
+    BatchHeaderBlobKey batch_header_blob_key = 2;
+  }
+}
+
+// Uniquely identifies a blob based on its auth header hash.
+message AuthHeaderBlobKey {
+  bytes auth_header_hash = 1;
+}
+
+// Uniquely identifies a blob based on its batch header hash and blob index.
+message BatchHeaderBlobKey {
+  bytes batch_header_hash = 1;
+  uint32 blob_index = 2;
+}
+
+// A unique identifier for a chunk.
+message ChunkKey {
+  BlobKey blob_key = 1;
+  uint32 chunk_index = 2;
+}
+
+// A blob.
+message BlobData {
+  bytes data = 1;
+}
+
+// A chunk of a blob.
+message ChunkData {
+  bytes data = 1;
+}

api/proto/disperser/disperser.proto

@@ -32,6 +32,18 @@ service Disperser {
 	// The blob should have been initially dispersed via this Disperser service
 	// for this API to work.
 	rpc RetrieveBlob(RetrieveBlobRequest) returns (RetrieveBlobReply) {}
+
+	////////////////////////////////////////////////////////////////////////////////////////////////
+	// These RPCs are a work in progress and are not yet fully functional. API may not be stable. //
+	////////////////////////////////////////////////////////////////////////////////////////////////
+
+	// Retrieves the requested blob from the disperser's backend.
+	// This RPC is is a work in progress with undefined behavior, use with caution.
+	rpc GetBlob(common.BlobKey) returns (common.BlobData) {}
+
+	// Retrieves the requested chunk from the Disperser's backend.
+	// This RPC is is a work in progress with undefined behavior, use with caution.
+	rpc GetChunk(common.ChunkKey) returns (common.ChunkData) {}
 }
 
 // Requests and Responses
@@ -249,4 +261,4 @@ message BatchHeader {
 	// The Disperser will encode and disperse the blobs based on the onchain info
 	// (e.g. operator stakes) at this block number.
 	uint32 reference_block_number = 4;
-}
+}

api/proto/lightnode/lightnode.proto

@@ -0,0 +1,24 @@
+syntax = "proto3";
+package lightnode;
+import "common/common.proto";
+option go_package = "github.com/Layr-Labs/eigenda/api/grpc/lightnode";
+
+///////////////////////////////////////////////////////////////////////////////////
+// Warning: light node APIs are currently in flux. This is not yet a stable API. //
+///////////////////////////////////////////////////////////////////////////////////
+
+service LightNode {
+	// GetChunk retrieves a specific chunk held by the light node.
+	rpc GetChunk(common.ChunkKey) returns (common.ChunkData) {}
+
+	// StreamAvailabilityStatus streams the availability status of all chunks assigned to the light node.
+	// For use by a DA node for monitoring the availability of chunks through its constellation of agent light nodes.
+	rpc StreamAvailabilityStatus(StreamAvailabilityStatusRequest) returns (stream common.ChunkKey) {}
+}
+
+// A request from a DA node to an agent light node to stream the availability status of all chunks
+// assigned to the light node.
+message StreamAvailabilityStatusRequest {
+	// TODO describe protocol for authentication
+	bytes authentication_token = 1;
+}

api/proto/node/node.proto

@@ -33,6 +33,24 @@ service Retrieval {
 	rpc GetBlobHeader(GetBlobHeaderRequest) returns (GetBlobHeaderReply) {}
 	// Retrieve node info metadata
 	rpc NodeInfo(NodeInfoRequest) returns (NodeInfoReply) {}
+
+	////////////////////////////////////////////////////////////////////////////////////////////////
+	// These RPCs are a work in progress and are not yet fully functional. API may not be stable. //
+	////////////////////////////////////////////////////////////////////////////////////////////////
+
+	// GetChunks retrieves all of the chunks for a blob held by the node. Eventually this will replace RetrieveChunks.
+	rpc GetChunks(common.BlobKey) returns (GetChunksReply) {}
+	// GetChunk retrieves a specific chunk for a blob custodied at the Node.
+	rpc GetChunk(common.ChunkKey) returns (common.ChunkData) {}
+	// StreamChunks requests a stream of chunks with a specific index.
+	rpc StreamChunks(stream StreamChunksRequest) returns (stream common.ChunkData) {}
+	// GetHeader is similar to RetrieveChunks, this just returns the header of the blob.
+	// Eventually this will replace GetBlobHeader.
+	rpc GetHeader(common.BlobKey) returns (GetBlobHeaderReply) {}
+	// StreamHeaders requests a stream all new headers.
+	rpc StreamHeaders(stream StreamHeadersRequest) returns (stream GetBlobHeaderReply) {}
+	// Retrieve node info metadata. Eventually this will replace NodeInfo.
+	rpc GetNodeInfo(GetNodeInfoRequest) returns (GetNodeInfoReply) {}
 }
 
 // Requests and replies
@@ -216,3 +234,40 @@ message NodeInfoReply {
 	uint32 num_cpu = 4;
 	uint64 mem_bytes = 5;
 }
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Messages for WIP RPCs. These are subject to change, do not consider these to be stable API. //
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Reply to GetChunksRequest.
+message GetChunksReply {
+	// The indices of the chunks sent. Each index corresponds to the chunk at the same position in the chunks field.
+	repeated uint32 chunk_indices = 1;
+	// The chunks this node has.
+	repeated common.ChunkData chunks = 2;
+}
+
+// Request that all new chunks with a particular index be sent to the client.
+message StreamChunksRequest {
+	// The quorum ID of the chunks to stream.
+	uint32 quorum_id = 1;
+	// The chunk index to start streaming from.
+	uint32 chunk_index = 2;
+}
+
+// Request that all new headers be sent.
+message StreamHeadersRequest {
+}
+
+// Node info request.
+message GetNodeInfoRequest {
+}
+
+// Node info reply.
+message GetNodeInfoReply {
+	string semver = 1;
+	string arch = 2;
+	string os = 3;
+	uint32 num_cpu = 4;
+	uint64 mem_bytes = 5;
+}

api/proto/retriever/retriever.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
 
 option go_package = "github.com/Layr-Labs/eigenda/api/grpc/retriever";
+import "common/common.proto";
 package retriever;
 
 // The Retriever is a service for retrieving chunks corresponding to a blob from
@@ -20,6 +21,14 @@ service Retriever {
 	// This fans out request to EigenDA Nodes to retrieve the chunks and returns the
 	// reconstructed original blob in response.
 	rpc RetrieveBlob(BlobRequest) returns (BlobReply) {}
+
+	////////////////////////////////////////////////////////////////////////////////////////////////
+	// These RPCs are a work in progress and are not yet fully functional. API may not be stable. //
+	////////////////////////////////////////////////////////////////////////////////////////////////
+
+	// Obtain the chunks necessary to reconstruct a blob and return it.
+	// Eventually this will replace RetrieveBlob.
+	rpc GetBlob(common.BlobKey) returns (common.BlobData) {}
 }
 
 message BlobRequest {