Some cleanup

Author: ZenGround0

pdp/contract/removals.go

@@ -1114,43 +1114,6 @@ func (p *PDPService) handleDeleteDataSetPiece(w http.ResponseWriter, r *http.Req
 		return
 	}
 
-	// Removals can only be drained once the data set has a proving schedule: the
-	// drain waits for the challenge window to close, and there is no window
-	// without one. Accepting a removal before then would build a queue that can
-	// never be drained, while blocking initProvingPeriod from ever succeeding.
-	var proveAtEpoch sql.NullInt64
-	err = p.db.QueryRow(ctx, `SELECT prove_at_epoch FROM pdp_data_sets WHERE id = $1`, dataSetId).Scan(&proveAtEpoch)
-	if err != nil {
-		httpServerError(w, http.StatusInternalServerError, "Failed to read data set proving schedule", err)
-		return
-	}
-	if !proveAtEpoch.Valid {
-		http.Error(w, fmt.Sprintf("data set %d has not started proving yet; retry once its first proving period is initialized", dataSetId),
-			http.StatusTooManyRequests)
-		return
-	}
-
-	// A drain transaction in flight means the queue is mid-processing. Adding to
-	// it now re-fills what is being drained and pushes the proving-period
-	// rollover further out, so refuse until the drain settles.
-	//
-	// Keyed on an in-flight message rather than the mere presence of a drain
-	// row: the migration seeds a row for every data set, so row existence would
-	// refuse every deletion until that sweep completed.
-	var draining bool
-	err = p.db.QueryRow(ctx, `
-		SELECT EXISTS (SELECT 1 FROM pdpv0_deletion_drain WHERE data_set = $1 AND msg_hash IS NOT NULL)
-	`, dataSetId).Scan(&draining)
-	if err != nil {
-		httpServerError(w, http.StatusInternalServerError, "Failed to read removal drain state", err)
-		return
-	}
-	if draining {
-		http.Error(w, fmt.Sprintf("data set %d is draining previously scheduled removals; retry once they are processed", dataSetId),
-			http.StatusTooManyRequests)
-		return
-	}
-
 	// Soft gate: refuse if the data set's on-chain removal queue is already at our
 	// conservative ceiling. This keeps us well clear of the on-chain MAX_ENQUEUED_REMOVALS.
 	pdpVerifier, err := contract.NewPDPVerifier(contract.ContractAddresses().PDPVerifier, p.ethClient)
@@ -1244,18 +1207,6 @@ func (p *PDPService) handleDeleteDataSetPiece(w http.ResponseWriter, r *http.Req
 			return false, err
 		}
 
-		// PDPVerifier no longer applies scheduled removals inside
-		// nextProvingPeriod, so the data set needs an explicit drain before it
-		// can roll over. Enqueue it in the same transaction as the send.
-		_, err = tx.Exec(`
-			INSERT INTO pdpv0_deletion_drain (data_set)
-			VALUES ($1)
-			ON CONFLICT (data_set) DO UPDATE SET blocked_at = NULL`, dataSetId)
-		if err != nil {
-			log.Errorw("Failed to enqueue removal drain", "dataSetId", dataSetId, "error", err)
-			return false, err
-		}
-
 		log.Infow("scheduled user requested deletion", "dataSetId", dataSetId, "pieceIDs", pieceIDsI64, "txHash", txHashLower)
 
 		return true, nil

pdp/handlers.go

@@ -192,7 +192,7 @@ func clearFailedProvingPeriodReconciliations(ctx context.Context, db *harmonydb.
 //
 // A zero next challenge epoch is ambiguous since FilOzone/pdp#297:
 // processPieceDeletions also clears it, on a perfectly healthy data set that
-// still has leaves and is simply due a fresh challenge at the next rollover.
+// still has leaves and is simply due a fresh challenge at the next proving period.
 // Leaf count is the discriminator -- only a zero challenge with zero leaves is a
 // genuinely emptied data set.
 func processEmptyProvingPeriods(ctx context.Context, db *harmonydb.DB, ethClient ethchain.EthClient, periods []confirmedProvingPeriod) error {
@@ -225,9 +225,6 @@ func processEmptyProvingPeriods(ctx context.Context, db *harmonydb.DB, ethClient
 			return xerrors.Errorf("failed to get leaf count for data set %d: %w", period.DataSetID, err)
 		}
 		if leafCount.Sign() > 0 {
-			// Leaves remain, so the challenge was cleared by a processed
-			// deletion rather than by the data set emptying. The proving
-			// schedule is still valid and nextProvingPeriod will resample.
 			log.Debugw("skipping empty-period reset; challenge cleared by processed deletions",
 				"dataSetId", period.DataSetID, "leafCount", leafCount.String())
 			continue
@@ -273,9 +270,3 @@ func clearProvingPeriodReconcileNeeded(ctx context.Context, db *harmonydb.DB, pe
 	}
 	return nil
 }
-
-// processPendingPieceDeletes, and its helpers, moved to
-// watch_process_deletions.go: removals are now applied by their own
-// transaction rather than by nextProvingPeriod. It is still called from here as
-// well, because the reconciliation is chain-authoritative and therefore correct
-// against a PDPVerifier that predates processPieceDeletions.