feat(warm-storage): add hasActivePieces and use it in resolveByProviderId (#852)

resolveByProviderId checked dataset emptiness with getActivePieceCount, which
is O(n) in piece count and reverts on large sets (FilOzone/pdp#265).
hasActivePieces reads a single piece (getActivePieces, limit 1) for an O(1)
boolean, and resolveByProviderId now uses it. Iteration/batching is unchanged.

Author: SgtPooki

packages/synapse-sdk/src/storage/context.ts

@@ -483,7 +483,7 @@ export class StorageContext {
     type EvaluatedDataSet = {
       dataSetId: bigint
       dataSetMetadata: Record<string, string>
-      activePieceCount: bigint
+      hasPieces: boolean
     }
 
     // Sort ascending by ID (oldest first) for deterministic selection
@@ -501,9 +501,9 @@ export class StorageContext {
       const batchResults: (EvaluatedDataSet | null)[] = await Promise.all(
         sortedDataSets.slice(i, i + BATCH_SIZE).map(async (dataSet) => {
           const { dataSetId } = dataSet
-          const [dataSetMetadata, activePieceCount] = await Promise.all([
+          const [dataSetMetadata, hasPieces] = await Promise.all([
             warmStorageService.getDataSetMetadata({ dataSetId }),
-            warmStorageService.getActivePieceCount({ dataSetId }),
+            warmStorageService.hasActivePieces({ dataSetId }),
           ])
 
           if (!metadataMatches(dataSetMetadata, requestedMetadata)) {
@@ -513,15 +513,15 @@ export class StorageContext {
           return {
             dataSetId,
             dataSetMetadata,
-            activePieceCount,
+            hasPieces,
           }
         })
       )
 
       for (const result of batchResults) {
         if (result == null) continue
 
-        if (result.activePieceCount > 0) {
+        if (result.hasPieces) {
           selectedDataSet = result
           break
         }
@@ -531,7 +531,7 @@ export class StorageContext {
         }
       }
 
-      if (selectedDataSet != null && selectedDataSet.activePieceCount > 0) {
+      if (selectedDataSet?.hasPieces) {
         break
       }
     }

packages/synapse-sdk/src/test/storage.test.ts

@@ -314,13 +314,13 @@ describe('StorageService', () => {
           ...Mocks.presets.basic,
           pdpVerifier: {
             ...Mocks.presets.basic.pdpVerifier,
-            getActivePieceCount: (args) => {
+            getActivePieces: (args) => {
               const [dataSetId] = args
               if (dataSetId === 2n) {
-                return [2n]
-              } else {
-                return [0n]
+                const cid = CID.parse('bafkzcibcd4bdomn3tgwgrh3g532zopskstnbrd2n3sxfqbze7rxt7vqn7veigmy')
+                return [[{ data: bytesToHex(cid.bytes) }], [101n], false]
               }
+              return [[], [], false]
             },
           },
           warmStorageView: {

packages/synapse-sdk/src/test/warm-storage-service.test.ts

@@ -8,7 +8,8 @@ import { calibration } from '@filoz/synapse-core/chains'
 import * as Mocks from '@filoz/synapse-core/mocks'
 import { assert } from 'chai'
 import { setup } from 'iso-web/msw'
-import { type Address, createWalletClient, http as viemHttp } from 'viem'
+import { CID } from 'multiformats/cid'
+import { type Address, bytesToHex, createWalletClient, http as viemHttp } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
 import { WarmStorageService } from '../warm-storage/index.ts'
 
@@ -47,6 +48,37 @@ describe('WarmStorageService', () => {
     })
   })
 
+  describe('hasActivePieces', () => {
+    it('should return true when the data set has at least one active piece', async () => {
+      const cid = CID.parse('bafkzcibcd4bdomn3tgwgrh3g532zopskstnbrd2n3sxfqbze7rxt7vqn7veigmy')
+      server.use(
+        Mocks.JSONRPC({
+          ...Mocks.presets.basic,
+          pdpVerifier: {
+            ...Mocks.presets.basic.pdpVerifier,
+            getActivePieces: () => [[{ data: bytesToHex(cid.bytes) }], [101n], false],
+          },
+        })
+      )
+      const warmStorageService = await createWarmStorageService()
+      assert.isTrue(await warmStorageService.hasActivePieces({ dataSetId: 1n }))
+    })
+
+    it('should return false when the data set has no active pieces', async () => {
+      server.use(
+        Mocks.JSONRPC({
+          ...Mocks.presets.basic,
+          pdpVerifier: {
+            ...Mocks.presets.basic.pdpVerifier,
+            getActivePieces: () => [[], [], false],
+          },
+        })
+      )
+      const warmStorageService = await createWarmStorageService()
+      assert.isFalse(await warmStorageService.hasActivePieces({ dataSetId: 1n }))
+    })
+  })
+
   describe('getDataSet', () => {
     it('should return a single data set by ID', async () => {
       server.use(Mocks.JSONRPC(Mocks.presets.basic))

packages/synapse-sdk/src/warm-storage/service.ts

@@ -292,6 +292,24 @@ export class WarmStorageService {
     return PDPVerifier.getActivePieceCount(this._client, { dataSetId: options.dataSetId })
   }
 
+  /**
+   * Report whether a data set has at least one active piece.
+   *
+   * Reads a single piece (`limit: 1`) rather than the full active-piece count, so
+   * the cost is independent of how many pieces the data set holds.
+   * @param options - Options for the data set
+   * @param options.dataSetId - The PDPVerifier data set ID
+   * @returns True when the data set has at least one active piece
+   */
+  async hasActivePieces(options: { dataSetId: bigint }): Promise<boolean> {
+    const { pieces } = await PDPVerifier.getActivePieces(this._client, {
+      dataSetId: options.dataSetId,
+      offset: 0n,
+      limit: 1n,
+    })
+    return pieces.length > 0
+  }
+
   // ========== Metadata Operations ==========
 
   /**