chore(disperser-client): Remove option to rely on disperser for commitment generation (#2320)

* Remove option to rely on disperser for commitment generation

Signed-off-by: litt3 <102969658+litt3@users.noreply.github.com>

* Fix docs

Signed-off-by: litt3 <102969658+litt3@users.noreply.github.com>

* Fix more docs

Signed-off-by: litt3 <102969658+litt3@users.noreply.github.com>

---------

Signed-off-by: litt3 <102969658+litt3@users.noreply.github.com>

Author: litt3

api/clients/v2/disperser_client.go

@@ -84,6 +84,9 @@ func NewDisperserClient(
 	if signer == nil {
 		return nil, fmt.Errorf("signer must be provided")
 	}
+	if committer == nil {
+		return nil, fmt.Errorf("committer must be provided")
+	}
 	if metrics == nil {
 		return nil, fmt.Errorf("metrics must be provided")
 	}
@@ -221,37 +224,9 @@ func (c *DisperserClient) DisperseBlob(
 
 	probe.SetStage("get_commitments")
 
-	var blobCommitments encoding.BlobCommitments
-	if c.committer == nil {
-		// if committer is not configured, get blob commitments from disperser
-		commitments, err := c.GetBlobCommitment(ctx, data)
-		if err != nil {
-			// Failover worthy error because it means the disperser is not responsive.
-			return nil, nil, api.NewErrorFailover(fmt.Errorf("GetBlobCommitment rpc: %w", err))
-		}
-		deserialized, err := encoding.BlobCommitmentsFromProtobuf(commitments.GetBlobCommitment())
-		if err != nil {
-			return nil, nil, fmt.Errorf("error deserializing blob commitments: %w", err)
-		}
-		blobCommitments = *deserialized
-
-		// We need to check that the disperser used the correct length. Even once checking the commitment from the
-		// disperser has been implemented, there is still an edge case where the disperser could truncate trailing 0s,
-		// yielding the wrong blob length, but not causing commitment verification to fail. It is important that the
-		// commitment doesn't report a blob length smaller than expected, since this could cause payload parsing to
-		// fail, if the length claimed in the encoded payload header is larger than the blob length in the commitment.
-		lengthFromCommitment := commitments.GetBlobCommitment().GetLength()
-		if lengthFromCommitment != uint32(symbolLength) {
-			return nil, nil, fmt.Errorf(
-				"blob commitment length (%d) from disperser doesn't match expected length (%d): %w",
-				lengthFromCommitment, symbolLength, err)
-		}
-	} else {
-		// if committer is configured, get commitments from committer
-		blobCommitments, err = c.committer.GetCommitmentsForPaddedLength(data)
-		if err != nil {
-			return nil, nil, fmt.Errorf("error getting blob commitments: %w", err)
-		}
+	blobCommitments, err := c.committer.GetCommitmentsForPaddedLength(data)
+	if err != nil {
+		return nil, nil, fmt.Errorf("get commitments for padded length: %w", err)
 	}
 
 	blobHeader := &corev2.BlobHeader{
@@ -330,24 +305,6 @@ func (c *DisperserClient) GetPaymentState(ctx context.Context) (*disperser_rpc.G
 	return reply, nil
 }
 
-// GetBlobCommitment is a utility method that calculates commitment for a blob payload.
-// While the blob commitment can be calculated by anyone, it requires SRS points to
-// be loaded. For service that does not have access to SRS points, this method can be
-// used to calculate the blob commitment in blob header, which is required for dispersal.
-func (c *DisperserClient) GetBlobCommitment(
-	ctx context.Context,
-	data []byte,
-) (*disperser_rpc.BlobCommitmentReply, error) {
-	request := &disperser_rpc.BlobCommitmentRequest{
-		Blob: data,
-	}
-	reply, err := c.clientPool.GetClient().GetBlobCommitment(ctx, request)
-	if err != nil {
-		return nil, fmt.Errorf("error while calling GetBlobCommitment: %w", err)
-	}
-	return reply, nil
-}
-
 // initOncePopulateAccountant initializes the accountant if it is not already initialized.
 // If initialization fails, it caches the error and will return it on every subsequent call.
 func (c *DisperserClient) initOncePopulateAccountant(ctx context.Context) error {

api/grpc/common/v2/common_v2.pb.go

@@ -38,7 +38,6 @@ message BlobHeader {
   // Users can check their reserved quorum numbers on the IPaymentVault's reservation struct: https://github.com/Layr-Labs/eigenda/blob/1430d56258b4e814b388e497320fd76354bfb478/contracts/src/interfaces/IPaymentVault.sol#L10
   repeated uint32 quorum_numbers = 2;
   // commitment is the KZG commitment to the blob.
-  // This commitment can either be constructed locally, or obtained by using the disperser's GetBlobCommitment RPC (see disperser_v2.proto).
   common.BlobCommitment commitment = 3;
   // payment_header contains payment information for the blob
   PaymentHeader payment_header = 4;

api/grpc/disperser/v2/disperser_v2_grpc.pb.go

@@ -21,8 +21,7 @@ service Disperser {
   // It is provided to help clients who are trying to construct a DisperseBlobRequest.blob_header
   // and don't have the ability to calculate the commitment themselves (expensive operation which requires SRS points).
   //
-  // For an example usage, see how our disperser_client makes a call to this endpoint when it doesn't have a local prover:
-  // https://github.com/Layr-Labs/eigenda/blob/6059c6a068298d11c41e50f5bcd208d0da44906a/api/clients/v2/disperser_client.go#L166
+  // DEPRECATED: This method is deprecated and will be removed in a future release.
   rpc GetBlobCommitment(BlobCommitmentRequest) returns (BlobCommitmentReply) {}
 
   // GetPaymentState is a utility method to get the payment state of a given account, at a given disperser.

api/proto/common/v2/common_v2.proto

@@ -41,12 +41,7 @@ sequenceDiagram
   %% Blob Creation and Dispersal Flow
   B->>SP: Send payload
   Note over SP: Encode payload into blob
-  alt
-          SP->>D: GetBlobCommitment(blob)
-          D-->>SP: blob_commitment
-    else
-            SP->>SP: Compute commitment locally
-    end
+  Note over SP: Compute commitment locally using SRS points
   Note over SP: Create blob_header including payment_header
   SP->>D: DisperseBlob(blob, blob_header)
   D-->>SP: QUEUED status + blob_header_hash

api/proto/disperser/v2/disperser_v2.proto

@@ -25,7 +25,6 @@ The disperser presents a [grpc v2 service](https://github.com/Layr-Labs/eigenda/
 $ EIGENDA_DISPERSER_PREPROD=disperser-preprod-holesky.eigenda.xyz:443
 $ grpcurl $EIGENDA_DISPERSER_PREPROD list disperser.v2.Disperser
 disperser.v2.Disperser.DisperseBlob
-disperser.v2.Disperser.GetBlobCommitment
 disperser.v2.Disperser.GetBlobStatus
 disperser.v2.Disperser.GetPaymentState
 ```

docs/spec/src/integration/spec.md

@@ -77,7 +77,7 @@ The `blobHeader` version refers to one of the `versionedBlobParams` structs defi
 
 #### BlobCommitment
 
-The `BlobCommitment` is a binding commitment to an EigenDA Blob. Due to the length field, a `BlobCommitment` uniquely represents a single `Blob`. The length field is added to the kzgCommitment to respect the binding property. It is used by the disperser to prove to EigenDA validators that the chunks they received belong to the original blob (or its Reed-Solomon extension). This commitment can either be computed locally by the *EigenDA Client* from the blob or generated by the disperser via the `GetBlobCommitment` [endpoint](./../../protobufs/generated/disperser_v2.md#disperserv2disperser_v2proto###disperser).
+The `BlobCommitment` is a binding commitment to an EigenDA Blob. Due to the length field, a `BlobCommitment` uniquely represents a single `Blob`. The length field is added to the kzgCommitment to respect the binding property. It is used by the disperser to prove to EigenDA validators that the chunks they received belong to the original blob (or its Reed-Solomon extension).
 
 
 ```protobuf

docs/spec/src/integration/spec/1-apis.md

@@ -223,17 +223,6 @@ Proxy behavior. The EigenDA proxy can return either the encoded payload or the d
   - With `?return_encoded_payload=true` or `?return_encoded_payload=1`, it only checks the blob against the kzg commitment and returns the encoded payload, it is useful when integrating with proof systems to control the data transformation.
   - Without parameters, it decodes and returns the rollup payload; on any decoding error, it returns HTTP 418.
 
-### Notes on Dispersal
-Dispersal:
-
-1. If the `BlobCertificate` was generated using the disperser’s `GetBlobCommitment` RPC endpoint, verify its contents:
-    1. verify KZG commitment
-    2. verify that `length` matches the expected value, based on the blob that was actually sent
-    3. verify the `lengthProof` using the `length` and `lengthCommitment`
-2. After dispersal, verify that the `BlobKey` actually dispersed by the disperser matches the locally computed `BlobKey`
-
-Note: The verification steps in point 1. for dispersal are not currently implemented. This route only makes sense for clients that want to avoid having large amounts of SRS data, but KZG commitment verification via Fiat-Shamir is required to do the verification without this data. Until the alternate verification method is implemented, usage of `GetBlobCommitment` places a correctness trust assumption on the disperser generating the commitment.
-
 ## Upgradable Quorums and Thresholds for Optimistic Verification
 ![image.png](../../assets/integration/router-in-fraud-proof.png)
 

docs/spec/src/integration/spec/3-data-structs.md

@@ -226,8 +226,6 @@ func (env *Config) generateDisperserV2Vars(ind int, logPath, dbPath, grpcPort st
 		DISPERSER_SERVER_GLOBAL_RATE_TABLE_NAME:  "e2e_v2_global_reservation",
 		DISPERSER_SERVER_CONTROLLER_ADDRESS:      fmt.Sprintf("localhost:%d", controllerGrpcPort),
 
-		// V2 inabox test is setup with a client that doesn't setup a client for some reason,
-		// so it calls the grpc GetBlobCommitment to generate commitments.
 		// DisperserV2 uses the V2 prover which always uses SRSOrder=2^28.
 		// So it needs the trailing g2 points to generate correct length commitments.
 		DISPERSER_SERVER_G2_TRAILING_PATH:               "../resources/srs/g2.trailing.point",