fix: Fixes dispute ids calculation (#46)

* Adds KlerosBadgeRequestBuilder

* Make KlerosBadgeRequestBuilder accepts disputeID

package.json

@@ -2,7 +2,7 @@
   "name": "thebadge-subgraph",
   "license": "MIT",
   "description": "Subgraph for TheBadge smart contracts",
-  "version": "1.1.2.rc1",
+  "version": "1.1.2.rc2",
   "scripts": {
     "codegen:goerli": "node codegen/render-templates.js goerli && graph codegen",
     "codegen:sepolia": "node codegen/render-templates.js sepolia && graph codegen",

src/mappings/klerosBadgeModelController.ts

@@ -5,28 +5,24 @@ import {
   BadgeModelKlerosMetaData,
   BadgeKlerosMetaData,
   _KlerosBadgeIdToBadgeId,
-  KlerosBadgeRequest,
   Evidence,
   BadgeModel,
   _ItemIDToEvidenceGroupIDToBadgeID,
-  ControllerConfig,
+  ControllerConfig
 } from "../../generated/schema";
 import {
   KlerosBadgeModelController,
   NewKlerosBadgeModel,
   MintKlerosBadge,
   Initialize
 } from "../../generated/KlerosBadgeModelController/KlerosBadgeModelController";
-import {
-  getArbitrationParamsIndex,
-  getTCRRequestIndex,
-  DISPUTE_OUTCOME_NONE,
-  getTBStatus
-} from "../utils";
+import { getTCRRequestIndex, getTBStatus } from "../utils";
 import { TheBadgeStore } from "../../generated/TheBadge/TheBadgeStore";
 import { TheBadgeModels } from "../../generated/TheBadgeModels/TheBadgeModels";
 import { KlerosBadgeModelControllerStore } from "../../generated/KlerosBadgeModelController/KlerosBadgeModelControllerStore";
 
+import { KlerosBadgeRequestBuilder } from "../utils/builders/KlerosBadgeRequestBuilder";
+
 // event Initialize(address indexed admin,address tcrFactory);
 export function handleKlerosContractInitialized(event: Initialize): void {
   const contractAddress = event.address.toHexString();
@@ -37,7 +33,7 @@ export function handleKlerosContractInitialized(event: Initialize): void {
   const tcrFactory = event.params.tcrFactory;
 
   const klerosBadgeModelControllerStore = KlerosBadgeModelControllerStore.bind(
-      klerosBadgeModelController.klerosBadgeModelControllerStore()
+    klerosBadgeModelController.klerosBadgeModelControllerStore()
   );
   const controllerConfig = new ControllerConfig(contractAddress);
   controllerConfig.verifyUserProtocolFee = klerosBadgeModelController.getVerifyUserProtocolFee();
@@ -125,27 +121,30 @@ export function handleMintKlerosBadge(event: MintKlerosBadge): void {
     Address.fromBytes(_badgeModelKlerosMetaData.tcrList),
     itemID
   );
-  const requestId = itemID.toHexString() + "-" + requestIndex.toString();
-  const request = new KlerosBadgeRequest(requestId);
   const tcrListAddress = Address.fromBytes(_badgeModelKlerosMetaData.tcrList);
   const tcr = LightGeneralizedTCR.bind(tcrListAddress);
-  request.type = "Registration";
-  request.createdAt = event.block.timestamp;
-  request.badgeKlerosMetaData = badgeId.toString();
-  request.requestIndex = requestIndex;
-  request.arbitrationParamsIndex = getArbitrationParamsIndex(tcrListAddress);
-  request.requester = klerosBadgeModelControllerStore
+
+  const disputeData = tcr.requestsDisputeData(itemID, requestIndex);
+  const requestID = itemID.toHexString() + "-" + requestIndex.toString();
+  const requesterAddress = klerosBadgeModelControllerStore
     .klerosBadges(badgeId)
     .getCallee();
-  request.numberOfEvidences = BigInt.fromI32(1);
-  request.disputed = false;
-  request.disputeOutcome = DISPUTE_OUTCOME_NONE;
-  request.resolved = false;
-  request.resolutionTime = BigInt.fromI32(0);
-  request.arbitrator = tcr.arbitrator();
+
+  const request = new KlerosBadgeRequestBuilder(
+    requestID,
+    "Registration",
+    event.block.timestamp,
+    badgeId.toString(),
+    requestIndex,
+    disputeData.getDisputeID(),
+    tcrListAddress,
+    requesterAddress,
+    tcr.arbitrator()
+  ).build();
+
   request.save();
 
-  const evidence = new Evidence(requestId + "-" + "0");
+  const evidence = new Evidence(requestID + "-" + "0");
   evidence.uri = event.params.evidence;
   evidence.timestamp = event.block.timestamp;
   evidence.request = request.id;

src/mappings/lightGeneralizedTCRMapping.ts

@@ -18,12 +18,9 @@ import {
   BadgeKlerosMetaData,
   _KlerosBadgeIdToBadgeId,
   ProtocolStatistic,
-  User,
   BadgeModel
 } from "../../generated/schema";
 import {
-  DISPUTE_OUTCOME_NONE,
-  getArbitrationParamsIndex,
   getFinalRuling,
   getTBStatus,
   loadUserCuratorStatisticsOrGetDefault,
@@ -35,6 +32,7 @@ import {
 } from "../utils";
 import { TheBadgeModels } from "../../generated/TheBadgeModels/TheBadgeModels";
 import { TheBadgeStore } from "../../generated/TheBadge/TheBadgeStore";
+import { KlerosBadgeRequestBuilder } from "../utils/builders/KlerosBadgeRequestBuilder";
 
 // Items on a TCR can be in 1 of 4 states:
 // - (0) Absent: The item is not registered on the TCR and there are no pending requests.
@@ -136,22 +134,23 @@ export function handleRequestSubmitted(event: RequestSubmitted): void {
   const tcrList = Address.fromBytes(badgeModelKlerosMetaData.tcrList);
   const requestIndex = badgeKlerosMetadata.numberOfRequests.toString();
   const requestID = itemID + "-" + requestIndex.toString();
+  const disputeData = tcr.requestsDisputeData(
+    event.params._itemID,
+    badgeKlerosMetadata.numberOfRequests
+  );
+
+  const request = new KlerosBadgeRequestBuilder(
+    requestID,
+    "Clearing",
+    event.block.timestamp,
+    badgeKlerosMetadata.id,
+    BigInt.fromString(requestIndex),
+    disputeData.getDisputeID(),
+    tcrList,
+    event.transaction.from,
+    tcr.arbitrator()
+  ).build();
 
-  const request = new KlerosBadgeRequest(requestID);
-  request.type = "Clearing";
-  request.createdAt = event.block.timestamp;
-  request.badgeKlerosMetaData = badgeKlerosMetadata.id;
-  request.requestIndex = BigInt.fromString(requestIndex);
-  request.arbitrationParamsIndex = getArbitrationParamsIndex(tcrList);
-  request.numberOfEvidences = BigInt.fromI32(1);
-  request.disputed = false;
-  request.disputeID = BigInt.fromI32(0);
-  request.challenger = event.transaction.from;
-  request.disputeOutcome = DISPUTE_OUTCOME_NONE;
-  request.resolved = false;
-  request.resolutionTime = BigInt.fromI32(0);
-  request.arbitrator = tcr.arbitrator();
-  request.requester = event.transaction.from;
   request.save();
 
   badgeKlerosMetadata.numberOfRequests = badgeKlerosMetadata.numberOfRequests.plus(
@@ -243,7 +242,7 @@ export function handleRequestChallenged(event: Dispute): void {
   // Marks the user as curator
   const userAddress = event.transaction.from.toHexString();
   const user = loadUserOrGetDefault(userAddress);
-  user.save()
+  user.save();
 
   if (!user) {
     log.error(`handleRequestChallenged - user with address: {} not found`, [

src/utils/builders/KlerosBadgeRequestBuilder.ts

@@ -0,0 +1,44 @@
+import { KlerosBadgeRequest } from "../../../generated/schema";
+import { Address, BigInt, Bytes } from "@graphprotocol/graph-ts";
+import { DISPUTE_OUTCOME_NONE, getArbitrationParamsIndex } from "../tcrUtils";
+
+export class KlerosBadgeRequestBuilder {
+  private klerosBadgeRequest: KlerosBadgeRequest;
+
+  constructor(
+    requestID: string,
+    type: string,
+    createdAt: BigInt,
+    badgeKlerosMetadata: string,
+    requestIndex: BigInt,
+    disputeID: BigInt,
+    tcrListAddress: Address,
+    requesterAddress: Bytes,
+    arbitrator: Bytes,
+    challengerAddress: Bytes | null = null
+  ) {
+    this.klerosBadgeRequest = new KlerosBadgeRequest(requestID);
+    this.klerosBadgeRequest.type = type;
+    this.klerosBadgeRequest.createdAt = createdAt;
+    this.klerosBadgeRequest.badgeKlerosMetaData = badgeKlerosMetadata;
+    this.klerosBadgeRequest.requestIndex = requestIndex;
+    this.klerosBadgeRequest.arbitrationParamsIndex = getArbitrationParamsIndex(
+      tcrListAddress
+    );
+    this.klerosBadgeRequest.requester = requesterAddress;
+    this.klerosBadgeRequest.challenger = challengerAddress || null;
+    this.klerosBadgeRequest.numberOfEvidences = BigInt.fromI32(1);
+    this.klerosBadgeRequest.resolutionTime = BigInt.fromI32(0);
+    this.klerosBadgeRequest.disputed = false;
+    this.klerosBadgeRequest.resolved = false;
+    this.klerosBadgeRequest.resolutionTx = null;
+    this.klerosBadgeRequest.disputeID = disputeID;
+    this.klerosBadgeRequest.disputeOutcome = DISPUTE_OUTCOME_NONE;
+    this.klerosBadgeRequest.arbitrator = arbitrator;
+    this.klerosBadgeRequest.save();
+  }
+
+  build(): KlerosBadgeRequest {
+    return this.klerosBadgeRequest;
+  }
+}