Update dispute.test.ts

Author: bpolania

packages/core-sdk/test/integration/dispute.test.ts

@@ -340,6 +340,16 @@ describe("Dispute Functions", () => {
     });
 
     it("should tag a single IP as infringing without using multicall", async () => {
+      /**
+       * Test Flow:
+       * 1. Set judgment on an existing dispute to mark it as valid
+       * 2. Verify the dispute state changed correctly after judgment
+       * 3. Try to tag a derivative IP using the judged dispute
+       */
+
+      // Step 1: Set dispute judgment using the judge wallet
+      // When judgment is true, the dispute's currentTag will be set to the targetTag
+      // When false, currentTag would be set to bytes32(0)
       const { request } = await publicClient.simulateContract({
         address: DISPUTE_MODULE_ADDRESS,
         abi: [SET_DISPUTE_JUDGEMENT_ABI],
@@ -350,28 +360,47 @@ describe("Dispute Functions", () => {
       const judgmentTxHash = await judgeWalletClient.writeContract(request);
       await publicClient.waitForTransactionReceipt({ hash: judgmentTxHash });
 
-      const disputeState = await publicClient.readContract({
+      // Step 2: Verify dispute state
+      // The disputes() function returns multiple values about the dispute:
+      // - targetTag: the tag we wanted to apply when raising the dispute
+      // - currentTag: the current state of the dispute after judgment
+      // After a successful judgment, currentTag should equal targetTag
+      const [
+        _targetIpId, // IP being disputed
+        _disputeInitiator, // Address that raised the dispute
+        _disputeTimestamp, // When dispute was raised
+        _arbitrationPolicy, // Policy used for arbitration
+        _disputeEvidenceHash, // Evidence hash for dispute
+        targetTag, // Tag we want to apply (e.g. "IMPROPER_REGISTRATION")
+        currentTag, // Current state of dispute
+        _infringerDisputeId, // Related dispute ID if this is a propagated tag
+      ] = await publicClient.readContract({
         address: disputeModuleAddress[aeneid],
         abi: disputeModuleAbi,
         functionName: "disputes",
         args: [disputeId],
       });
+      expect(currentTag).to.equal(targetTag); // Verify judgment was recorded correctly
 
-      expect(disputeState[6]).to.equal(disputeState[5]);
-
+      // Step 3: Attempt to tag a derivative IP
+      // This will fail if:
+      // - The dispute is not in a valid state (still IN_DISPUTE or cleared)
+      // - The IP we're trying to tag is not actually a derivative of the disputed IP
+      // - The dispute has already been used to tag this IP
       const response = await clientA.dispute.tagIfRelatedIpInfringed({
         infringementTags: [
           {
-            ipId: childIpId,
-            disputeId: disputeId,
+            ipId: childIpId, // The derivative IP to tag
+            disputeId: disputeId, // Using the judged dispute as basis for tagging
           },
         ],
         options: {
-          useMulticallWhenPossible: false,
+          useMulticallWhenPossible: false, // Force single transaction instead of batch
         },
         txOptions: { waitForTransaction: true },
       });
 
+      // Verify we got the expected response
       expect(response).to.have.lengthOf(1);
       expect(response[0].txHash).to.be.a("string").and.not.empty;
     });