package node

Get desktop application:
View/edit binary Protocol Buffers messages

• rpc StoreChunks (StoreChunksRequest, StoreChunksReply)

  node.proto:19

  StoreChunks validates that the chunks match what the Node is supposed to receive ( different Nodes are responsible for different chunks, as EigenDA is horizontally sharded) and is correctly coded (e.g. each chunk must be a valid KZG multiproof) according to the EigenDA protocol. It also stores the chunks along with metadata for the protocol-defined length of custody. It will return a signature at the end to attest to the data in this request it has processed.

  message StoreChunksRequest

  node.proto:44

  • optional BatchHeader batch_header = 1

    Which batch this request is for.

  • repeated Blob blobs = 2

    The chunks for each blob in the batch to be stored in an EigenDA Node.

  message StoreChunksReply

  node.proto:51

  • bytes signature = 1

    The operator's BLS signature signed on the batch header hash.

• rpc StoreBlobs (StoreBlobsRequest, StoreBlobsReply)

  node.proto:24

  StoreBlobs is similar to StoreChunks, but it stores the blobs using a different storage schema so that the stored blobs can later be aggregated by AttestBatch method to a bigger batch. StoreBlobs + AttestBatch will eventually replace and deprecate StoreChunks method. DEPRECATED: StoreBlobs method is not used

  message StoreBlobsRequest

  node.proto:56

  • repeated Blob blobs = 1

    Blobs to store

  • uint32 reference_block_number = 2

    The reference block number whose state is used to encode the blobs

  message StoreBlobsReply

  node.proto:63

  • repeated google.protobuf.BytesValue signatures = 1

    The operator's BLS sgnature signed on the blob header hashes. The ordering of the signatures must match the ordering of the blobs sent in the request, with empty signatures in the places for discarded blobs.

• rpc AttestBatch (AttestBatchRequest, AttestBatchReply)

  node.proto:28

  AttestBatch is used to aggregate the batches stored by StoreBlobs method to a bigger batch. It will return a signature at the end to attest to the aggregated batch. DEPRECATED: AttestBatch method is not used

  message AttestBatchRequest

  node.proto:70

  • optional BatchHeader batch_header = 1

    header of the batch

  • repeated bytes blob_header_hashes = 2

    the header hashes of all blobs in the batch

  message AttestBatchReply

  node.proto:77

  • bytes signature = 1

• rpc NodeInfo (NodeInfoRequest, NodeInfoReply)

  node.proto:30

  Retrieve node info metadata

• rpc RetrieveChunks (RetrieveChunksRequest, RetrieveChunksReply)

  node.proto:35

  RetrieveChunks retrieves the chunks for a blob custodied at the Node.

  message RetrieveChunksRequest

  node.proto:81

  • bytes batch_header_hash = 1

    The hash of the ReducedBatchHeader defined onchain, see: https://github.com/Layr-Labs/eigenda/blob/master/contracts/src/interfaces/IEigenDAServiceManager.sol#L43 This identifies which batch to retrieve for.

  • uint32 blob_index = 2

    Which blob in the batch to retrieve for (note: a batch is logically an ordered list of blobs).

  • uint32 quorum_id = 3

    Which quorum of the blob to retrieve for (note: a blob can have multiple quorums and the chunks for different quorums at a Node can be different). The ID must be in range [0, 254].

  message RetrieveChunksReply

  node.proto:103

  • repeated bytes chunks = 1

    All chunks the Node is storing for the requested blob per RetrieveChunksRequest.

  • ChunkEncodingFormat chunk_encoding_format = 2

    How the above chunks are encoded.

• rpc GetBlobHeader (GetBlobHeaderRequest, GetBlobHeaderReply)

  node.proto:37

  GetBlobHeader is similar to RetrieveChunks, this just returns the header of the blob.

  message GetBlobHeaderRequest

  node.proto:111

  See RetrieveChunksRequest for documentation of each parameter of GetBlobHeaderRequest.

  • bytes batch_header_hash = 1

  • uint32 blob_index = 2

  • uint32 quorum_id = 3

  message GetBlobHeaderReply

  node.proto:117

  • optional BlobHeader blob_header = 1

    The header of the blob requested per GetBlobHeaderRequest.

  • optional MerkleProof proof = 2

    Merkle proof that returned blob header belongs to the batch and is the batch's MerkleProof.index-th blob. This can be checked against the batch root on chain.

• rpc NodeInfo (NodeInfoRequest, NodeInfoReply)

  node.proto:39

  Retrieve node info metadata

BatchHeader (see core/data.go#BatchHeader)

Used in: AttestBatchRequest, StoreChunksRequest

• bytes batch_root = 1

  The root of the merkle tree with hashes of blob headers as leaves.

• uint32 reference_block_number = 3

  The Ethereum block number at which the batch is dispersed.

In EigenDA, the original blob to disperse is encoded as a polynomial via taking taking different point evaluations (i.e. erasure coding). These points are split into disjoint subsets which are assigned to different operator nodes in the EigenDA network. The data in this message is a subset of these points that are assigned to a single operator node.

Used in: StoreBlobsRequest, StoreChunksRequest

• optional BlobHeader header = 1

  Which (original) blob this is for.

• repeated Bundle bundles = 2

  Each bundle contains all chunks for a single quorum of the blob. The number of bundles must be equal to the total number of quorums associated with the blob, and the ordering must be the same as BlobHeader.quorum_headers. Note: an operator may be in some but not all of the quorums; in that case the bundle corresponding to that quorum will be empty.

Used in: Blob, GetBlobHeaderReply

• optional common.G1Commitment commitment = 1

  The KZG commitment to the polynomial representing the blob.

• optional G2Commitment length_commitment = 2

  The KZG commitment to the polynomial representing the blob on G2, it is used for proving the degree of the polynomial

• optional G2Commitment length_proof = 3

  The low degree proof. It's the KZG commitment to the polynomial shifted to the largest SRS degree.

• uint32 length = 4

  The length of the original blob in number of symbols (in the field where the polynomial is defined).

• repeated BlobQuorumInfo quorum_headers = 5

  The params of the quorums that this blob participates in.

• string account_id = 6

  The ID of the user who is dispersing this blob to EigenDA.

• uint32 reference_block_number = 7

  The reference block number whose state is used to encode the blob

See BlobQuorumParam as defined in api/proto/disperser/disperser.proto

Used in: BlobHeader

• uint32 quorum_id = 1

• uint32 adversary_threshold = 2

• uint32 confirmation_threshold = 3

• uint32 chunk_length = 4

• uint32 ratelimit = 5

A Bundle is the collection of chunks associated with a single blob, for a single operator and a single quorum.

Used in: Blob

• repeated bytes chunks = 1

  Each chunk corresponds to a collection of points on the polynomial. Each chunk has same number of points.

• bytes bundle = 2

  All chunks of the bundle encoded in a byte array.

This describes how the chunks returned in RetrieveChunksReply are encoded. Used to facilitate the decoding of chunks.

Used in: RetrieveChunksReply

• UNKNOWN = 0

• GNARK = 1

• GOB = 2

Used in: BlobHeader

• bytes x_a0 = 1

  The A0 element of the X coordinate of G2 point.

• bytes x_a1 = 2

  The A1 element of the X coordinate of G2 point.

• bytes y_a0 = 3

  The A0 element of the Y coordinate of G2 point.

• bytes y_a1 = 4

  The A1 element of the Y coordinate of G2 point.

Used in: GetBlobHeaderReply

• repeated bytes hashes = 1

  The proof itself.

• uint32 index = 2

  Which index (the leaf of the Merkle tree) this proof is for.

Node info reply

Used as response type in: Dispersal.NodeInfo, Retrieval.NodeInfo

• string semver = 1

• string arch = 2

• string os = 3

• uint32 num_cpu = 4

• uint64 mem_bytes = 5

Node info request

Used as request type in: Dispersal.NodeInfo, Retrieval.NodeInfo

(message has no fields)