fix(test): msp and solochain-evm tests use proper fisherman deletion flow

Author: snowmead

test/suites/integration/msp/duplicate-storage-request.test.ts

@@ -5,6 +5,7 @@ import {
   type FileMetadata,
   shUser,
   sleep,
+  type SqlClient,
   waitFor
 } from "../../../util";
 
@@ -17,15 +18,27 @@ await describeMspNet(
     indexerMode: "fishing",
     standaloneIndexer: true
   },
-  ({ before, createUserApi, createBspApi, createMsp1Api, it, getLaunchResponse }) => {
+  ({
+    before,
+    createUserApi,
+    createBspApi,
+    createMsp1Api,
+    createFishermanApi,
+    it,
+    getLaunchResponse,
+    createSqlClient,
+    createIndexerApi
+  }) => {
     let userApi: EnrichedBspApi;
     let bspApi: EnrichedBspApi;
     let mspApi: EnrichedBspApi;
+    let sql: SqlClient;
 
     const bucketId1 = "cloud-bucket-1";
     const bucketId2 = "cloud-bucket-2";
     let file1: FileMetadata;
     let file2: FileMetadata;
+    let indexerApi: EnrichedBspApi;
 
     // Helper to build and sign a file deletion intention
     const buildSignedDelete = (fileKey: string) => {
@@ -44,9 +57,17 @@ await describeMspNet(
       userApi = await createUserApi();
       bspApi = await createBspApi();
       const maybeMspApi = await createMsp1Api();
+      sql = createSqlClient();
 
       assert(maybeMspApi, "MSP API not available");
       mspApi = maybeMspApi;
+
+      assert(createFishermanApi, "Fisherman API not available");
+      await createFishermanApi();
+
+      assert(createIndexerApi, "Indexer API not available");
+      indexerApi = await createIndexerApi();
+      await indexerApi.indexer.waitForIndexing({ producerApi: userApi, sql });
     });
 
     it("Network launches and can be queried", async () => {
@@ -230,68 +251,73 @@ await describeMspNet(
         signer: shUser
       });
 
-      // Fisherman submits delete_files extrinsics (MSP + BSP)
-      await userApi.assert.extrinsicPresent({
-        method: "deleteFiles",
-        module: "fileSystem",
-        checkTxPool: true,
-        assertLength: 2 // 1 for MSP and 1 for BSP
-      });
-      const block = await userApi.block.seal();
+      // Finalize the block on the indexer node and wait for the indexer to process the block
+      await indexerApi.indexer.waitForIndexing({ producerApi: userApi, sql });
 
-      // Verify file removed from first bucket's forest
-      await waitFor({
-        lambda: async () =>
-          (await mspApi.rpc.storagehubclient.isFileInForest(file1.bucketId, file1.fileKey)).isFalse
+      // Wait for fisherman to process the file deletions
+      await userApi.fisherman.retryableWaitAndVerifyBatchDeletions({
+        blockProducerApi: userApi,
+        deletionType: "User",
+        expectExt: 2,
+        userApi,
+        bspApi,
+        expectedBspCount: 1,
+        mspApi: mspApi,
+        expectedBucketCount: 1,
+        maxRetries: 3
       });
 
-      // Finalising block in MSP node to trigger the event to delete the file.
-      // First we make sure the MSP is caught up to the block.
-      // Actually, it should trigger, but the file still shouldn't be deleted.
-      await mspApi.wait.nodeCatchUpToChainTip(userApi);
-      await mspApi.block.finaliseBlock(block.blockReceipt.blockHash.toString());
+      // Non-producer nodes must explicitly finalize imported blocks to trigger file deletion
+      // Producer node (user) has finalized blocks, but BSP and MSP must finalize locally
+      const finalisedBlockHash = await userApi.rpc.chain.getFinalizedHead();
 
-      // Verify that the file metadata from the first file was removed from
-      // the file storage of the MSP, meaning that it should respond that this
-      // fileKey is not in the file storage.
-      await waitFor({
-        lambda: async () =>
-          (await mspApi.rpc.storagehubclient.isFileInFileStorage(file1.fileKey)).isFileNotFound
-      });
+      await bspApi.wait.blockImported(finalisedBlockHash.toString());
+      await bspApi.block.finaliseBlock(finalisedBlockHash.toString());
 
-      // But verify MSP still has the file in file storage via the second file key,
-      // meaning that for that second file key it has both the file metadata and the file content
-      // (which was the same file content as the first file)
-      await waitFor({
-        lambda: async () =>
-          (await mspApi.rpc.storagehubclient.isFileInFileStorage(file2.fileKey)).isFileFound
-      });
+      await mspApi.wait.blockImported(finalisedBlockHash.toString());
+      await mspApi.block.finaliseBlock(finalisedBlockHash.toString());
 
-      // Verify file removed from BSP's forest
+      // Verify that the file metadata from the second file was removed from
+      // the file storage of the BSP and MSP, meaning that it should respond that this
+      // fileKey is not in the file storage. Now the file content should have
+      // been deleted from the file storage as well.
       await waitFor({
-        lambda: async () =>
-          (await bspApi.rpc.storagehubclient.isFileInForest(null, file1.fileKey)).isFalse
-      });
+        lambda: async () => {
+          // Check file is NOT in BSP forest
+          const bspForestResult = await bspApi.rpc.storagehubclient.isFileInForest(
+            null,
+            file1.fileKey
+          );
+          if (bspForestResult.isTrue) {
+            return false;
+          }
 
-      // Finalising block in BSP node to trigger the event to delete the file.
-      // First we make sure the BSP is caught up to the block.
-      await bspApi.wait.nodeCatchUpToChainTip(userApi);
-      await bspApi.block.finaliseBlock(block.blockReceipt.blockHash.toString());
+          // Check file is NOT in BSP file storage
+          const bspFileStorageResult = await bspApi.rpc.storagehubclient.isFileInFileStorage(
+            file1.fileKey
+          );
+          if (bspFileStorageResult.isFileFound) {
+            return false;
+          }
 
-      // Verify that the file metadata from the first file was removed from
-      // the file storage of the BSP, meaning that it should respond that this
-      // fileKey is not in the file storage.
-      await waitFor({
-        lambda: async () =>
-          (await bspApi.rpc.storagehubclient.isFileInFileStorage(file1.fileKey)).isFileNotFound
-      });
+          // Check file is NOT in MSP forest
+          const mspForestResult = await mspApi.rpc.storagehubclient.isFileInForest(
+            file2.bucketId,
+            file1.fileKey
+          );
+          if (mspForestResult.isTrue) {
+            return false;
+          }
 
-      // But verify BSP still has the file in file storage via the second file key,
-      // meaning that for that second file key it has both the file metadata and the file content
-      // (which was the same file content as the first file)
-      await waitFor({
-        lambda: async () =>
-          (await bspApi.rpc.storagehubclient.isFileInFileStorage(file2.fileKey)).isFileFound
+          // Check file is NOT in MSP file storage
+          const mspFileStorageResult = await mspApi.rpc.storagehubclient.isFileInFileStorage(
+            file1.fileKey
+          );
+          if (mspFileStorageResult.isFileFound) {
+            return false;
+          }
+          return true;
+        }
       });
     });
 

test/suites/integration/solochain-evm/sdk-precompiles.test.ts

@@ -15,7 +15,7 @@ import {
 import { MspClient } from "@storagehub-sdk/msp-client";
 import { createPublicClient, createWalletClient, defineChain, http, getAddress } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-import { describeMspNet, type EnrichedBspApi, ShConsts } from "../../../util";
+import { describeMspNet, type EnrichedBspApi, ShConsts, type SqlClient } from "../../../util";
 import { SH_EVM_SOLOCHAIN_CHAIN_ID } from "../../../util/evmNet/consts";
 import { ALITH_PRIVATE_KEY } from "../../../util/evmNet/keyring";
 
@@ -26,15 +26,18 @@ await describeMspNet(
     runtimeType: "solochain",
     indexer: true,
     backend: true,
-    fisherman: true
+    fisherman: true,
+    standaloneIndexer: true
   },
-  ({ before, it, createUserApi, createMsp1Api }) => {
+  ({ before, it, createUserApi, createMsp1Api, createSqlClient, createIndexerApi }) => {
     let userApi: EnrichedBspApi;
     let msp1Api: EnrichedBspApi;
+    let indexerApi: EnrichedBspApi;
     let storageHubClient: InstanceType<typeof StorageHubClient>;
     let publicClient: ReturnType<typeof createPublicClient>;
     let walletClient: ReturnType<typeof createWalletClient>;
     let account: ReturnType<typeof privateKeyToAccount>;
+    let sql: SqlClient;
     let bucketId: string;
     let fileManager: FileManager;
     let fileKey: H256;
@@ -52,6 +55,7 @@ await describeMspNet(
       } else {
         throw new Error("MSP API for first MSP not available");
       }
+      sql = createSqlClient();
 
       // Set up the StorageHub SDK client using viem
       const rpcUrl = `http://127.0.0.1:${ShConsts.NODE_INFOS.user.port}`;
@@ -105,6 +109,10 @@ await describeMspNet(
       // Set up the authentication with the MSP backend
       const siweSession = await mspClient.auth.SIWE(walletClient);
       sessionToken = siweSession.token;
+
+      assert(createIndexerApi, "Indexer API not available");
+      indexerApi = await createIndexerApi();
+      await indexerApi.indexer.waitForIndexing({ producerApi: userApi, sql });
     });
 
     it("Postgres DB is ready", async () => {
@@ -528,6 +536,10 @@ await describeMspNet(
       // Verify the deletion request was enqueued on-chain
       await userApi.assert.eventPresent("fileSystem", "FileDeletionRequested");
 
+      // Finalize the block on the indexer node and wait for the indexer to process the block
+      await indexerApi.indexer.waitForIndexing({ producerApi: userApi, sql });
+
+      // Wait for fisherman to process the file deletions
       await userApi.fisherman.retryableWaitAndVerifyBatchDeletions({
         blockProducerApi: userApi,
         deletionType: "User",