feat: subgraph support for shutter disputekit in devnet

subgraph/core/src/DisputeKitClassic.ts

@@ -9,7 +9,7 @@ import {
   CommitCast,
 } from "../generated/DisputeKitClassic/DisputeKitClassic";
 import { KlerosCore } from "../generated/KlerosCore/KlerosCore";
-import { ClassicDispute, ClassicJustification, ClassicRound, ClassicVote, Dispute } from "../generated/schema";
+import { ClassicDispute, ClassicJustification, ClassicRound, ClassicVote, Dispute, Round } from "../generated/schema";
 import { ensureClassicContributionFromEvent } from "./entities/ClassicContribution";
 import { createClassicDisputeFromEvent } from "./entities/ClassicDispute";
 import {
@@ -19,23 +19,36 @@ import {
   updateCountsAndGetCurrentRuling,
 } from "./entities/ClassicRound";
 import { ensureClassicVote } from "./entities/ClassicVote";
-import { ONE, ZERO } from "./utils";
-
-export const DISPUTEKIT_ID = "1";
+import { ONE, extractDisputeKitIDFromExtraData } from "./utils";
 
 export function handleDisputeCreation(event: DisputeCreation): void {
   const disputeID = event.params._coreDisputeID.toString();
-  createClassicDisputeFromEvent(event);
-  const numberOfChoices = event.params._numberOfChoices;
-  createClassicRound(disputeID, numberOfChoices, ZERO);
+  const disputeKitID = extractDisputeKitIDFromExtraData(event.params._extraData);
+
+  const disputeKitClassic = DisputeKitClassic.bind(event.address);
+  const klerosCore = KlerosCore.bind(disputeKitClassic.core());
+  const totalRounds = klerosCore.getNumberOfRounds(event.params._coreDisputeID);
+  const newRoundIndex = totalRounds.minus(ONE);
+
+  createClassicDisputeFromEvent(event, disputeKitID, newRoundIndex);
+  createClassicRound(disputeID, event.params._numberOfChoices, newRoundIndex, disputeKitID);
 }
 
 export function handleCommitCast(event: CommitCast): void {
-  const coreDisputeID = event.params._coreDisputeID;
-  const coreDispute = Dispute.load(coreDisputeID.toString());
-  const classicDisputeID = `${DISPUTEKIT_ID}-${coreDisputeID}`;
+  const coreDisputeID = event.params._coreDisputeID.toString();
+  const coreDispute = Dispute.load(coreDisputeID);
+  if (!coreDispute) return;
+
+  const coreCurrentRound = Round.load(coreDispute.currentRound);
+  if (!coreCurrentRound) return;
+
+  const disputeKitID = coreCurrentRound.disputeKit;
+
+  const classicDisputeID = `${disputeKitID}-${coreDisputeID}`;
+
   const classicDispute = ClassicDispute.load(classicDisputeID);
-  if (!classicDispute || !coreDispute) return;
+  if (!classicDispute) return;
+
   const currentLocalRoundID = classicDispute.id + "-" + classicDispute.currentLocalRoundIndex.toString();
   const voteIDs = event.params._voteIDs;
   for (let i = 0; i < voteIDs.length; i++) {
@@ -55,9 +68,18 @@ export function handleVoteCast(event: VoteCast): void {
   const juror = event.params._juror.toHexString();
   const coreDisputeID = event.params._coreDisputeID.toString();
   const coreDispute = Dispute.load(coreDisputeID);
-  const classicDisputeID = `${DISPUTEKIT_ID}-${coreDisputeID}`;
+  if (!coreDispute) return;
+
+  const coreCurrentRound = Round.load(coreDispute.currentRound);
+  if (!coreCurrentRound) return;
+
+  const disputeKitID = coreCurrentRound.disputeKit;
+
+  const classicDisputeID = `${disputeKitID}-${coreDisputeID}`;
+
   const classicDispute = ClassicDispute.load(classicDisputeID);
-  if (!classicDispute || !coreDispute) return;
+  if (!classicDispute) return;
+
   const choice = event.params._choice;
   const currentLocalRoundID = classicDispute.id + "-" + classicDispute.currentLocalRoundIndex.toString();
   const voteIDs = event.params._voteIDs;
@@ -70,6 +92,7 @@ export function handleVoteCast(event: VoteCast): void {
   justification.transactionHash = event.transaction.hash.toHexString();
   justification.timestamp = event.block.timestamp;
   justification.save();
+
   const currentRulingInfo = updateCountsAndGetCurrentRuling(
     currentLocalRoundID,
     choice,
@@ -78,6 +101,7 @@ export function handleVoteCast(event: VoteCast): void {
   coreDispute.currentRuling = currentRulingInfo.ruling;
   coreDispute.tied = currentRulingInfo.tied;
   coreDispute.save();
+
   let classicVote: ClassicVote;
   for (let i = 0; i < voteIDs.length; i++) {
     classicVote = ensureClassicVote(currentLocalRoundID, juror, voteIDs[i], coreDispute);
@@ -97,7 +121,16 @@ export function handleChoiceFunded(event: ChoiceFunded): void {
   const coreDisputeID = event.params._coreDisputeID.toString();
   const coreRoundIndex = event.params._coreRoundID.toString();
   const choice = event.params._choice;
-  const roundID = `${DISPUTEKIT_ID}-${coreDisputeID}-${coreRoundIndex}`;
+
+  const coreDispute = Dispute.load(coreDisputeID);
+  if (!coreDispute) return;
+
+  const roundId = `${coreDisputeID}-${coreRoundIndex}`;
+  const coreRound = Round.load(roundId);
+  if (!coreRound) return;
+  const disputeKitID = coreRound.disputeKit;
+
+  const roundID = `${disputeKitID}-${coreDisputeID}-${coreRoundIndex}`;
 
   const localRound = ClassicRound.load(roundID);
   if (!localRound) return;
@@ -123,13 +156,18 @@ export function handleChoiceFunded(event: ChoiceFunded): void {
 
     localRound.feeRewards = localRound.feeRewards.minus(appealCost);
 
-    const localDispute = ClassicDispute.load(`${DISPUTEKIT_ID}-${coreDisputeID}`);
+    const newDisputeKitID = roundInfo.disputeKitID;
+
+    const localDispute = ClassicDispute.load(`${disputeKitID}-${coreDisputeID}`);
     if (!localDispute) return;
-    const newRoundIndex = localDispute.currentLocalRoundIndex.plus(ONE);
-    const numberOfChoices = localDispute.numberOfChoices;
-    localDispute.currentLocalRoundIndex = newRoundIndex;
-    localDispute.save();
-    createClassicRound(coreDisputeID, numberOfChoices, newRoundIndex);
+
+    if (BigInt.fromString(disputeKitID) === newDisputeKitID) {
+      const newRoundIndex = localDispute.currentLocalRoundIndex.plus(ONE);
+      const numberOfChoices = localDispute.numberOfChoices;
+      localDispute.currentLocalRoundIndex = newRoundIndex;
+      localDispute.save();
+      createClassicRound(coreDisputeID, numberOfChoices, newRoundIndex, disputeKitID);
+    }
   }
 
   localRound.save();
@@ -144,7 +182,16 @@ export function handleWithdrawal(event: Withdrawal): void {
   // check if all appeal fees have been withdrawn
   const coreDisputeID = event.params._coreDisputeID.toString();
   const coreRoundIndex = event.params._coreRoundID.toString();
-  const roundID = `${DISPUTEKIT_ID}-${coreDisputeID}-${coreRoundIndex}`;
+
+  const coreDispute = Dispute.load(coreDisputeID);
+  if (!coreDispute) return;
+
+  const roundId = `${coreDisputeID}-${coreRoundIndex}`;
+  const coreRound = Round.load(roundId);
+  if (!coreRound) return;
+  const disputeKitID = coreRound.disputeKit;
+
+  const roundID = `${disputeKitID}-${coreDisputeID}-${coreRoundIndex}`;
 
   const localRound = ClassicRound.load(roundID);
   if (!localRound) return;

subgraph/core/src/KlerosCore.ts

@@ -156,7 +156,7 @@ export function handleNewPeriod(event: NewPeriod): void {
           updateTotalLeaderboardJurors(ONE, event.block.timestamp);
         }
 
-        // Since this is a ClassicVote entity, this will only work for the Classic DisputeKit (which has ID "1").
+        // Since this is a ClassicVote entity, this will only work for the ClassicDisputeKit and ShutterDisputeKit.
         const vote = ClassicVote.load(`${round.disputeKit}-${draw.id}`);
 
         if (!vote) {

subgraph/core/src/entities/ClassicContribution.ts

@@ -1,13 +1,23 @@
-import { ClassicContribution } from "../../generated/schema";
+import { ClassicContribution, Dispute, DisputeKit, Round } from "../../generated/schema";
 import { Contribution as ContributionEvent, Withdrawal } from "../../generated/DisputeKitClassic/DisputeKitClassic";
-import { DISPUTEKIT_ID } from "../DisputeKitClassic";
 import { ensureUser } from "./User";
 
 export function ensureClassicContributionFromEvent<T>(event: T): ClassicContribution | null {
   if (!(event instanceof ContributionEvent) && !(event instanceof Withdrawal)) return null;
   const coreDisputeID = event.params._coreDisputeID.toString();
   const coreRoundIndex = event.params._coreRoundID.toString();
-  const roundID = `${DISPUTEKIT_ID}-${coreDisputeID}-${coreRoundIndex}`;
+
+  const coreDispute = Dispute.load(coreDisputeID);
+  if (!coreDispute) return null;
+
+  const roundId = `${coreDisputeID}-${coreRoundIndex}`;
+  const coreRound = Round.load(roundId);
+  if (!coreRound) return null;
+
+  const disputeKitID = coreRound.disputeKit;
+
+  const roundID = `${disputeKitID}-${coreDisputeID}-${coreRoundIndex}`;
+
   ensureUser(event.params._contributor.toHexString());
   const contributor = event.params._contributor.toHexString();
   const choice = event.params._choice;

subgraph/core/src/entities/ClassicDispute.ts

@@ -1,12 +1,12 @@
+import { BigInt } from "@graphprotocol/graph-ts";
 import { DisputeCreation } from "../../generated/DisputeKitClassic/DisputeKitClassic";
 import { ClassicDispute } from "../../generated/schema";
-import { ZERO } from "../utils";
 
-export function createClassicDisputeFromEvent(event: DisputeCreation): void {
+export function createClassicDisputeFromEvent(event: DisputeCreation, disputeKitID: string, roundIndex: BigInt): void {
   const coreDisputeID = event.params._coreDisputeID.toString();
-  const classicDispute = new ClassicDispute(`1-${coreDisputeID}`);
+  const classicDispute = new ClassicDispute(`${disputeKitID}-${coreDisputeID}`);
   classicDispute.coreDispute = coreDisputeID;
-  classicDispute.currentLocalRoundIndex = ZERO;
+  classicDispute.currentLocalRoundIndex = roundIndex;
   classicDispute.numberOfChoices = event.params._numberOfChoices;
   classicDispute.extraData = event.params._extraData;
   classicDispute.timestamp = event.block.timestamp;

subgraph/core/src/entities/ClassicRound.ts

@@ -1,10 +1,15 @@
 import { BigInt } from "@graphprotocol/graph-ts";
 import { Contribution } from "../../generated/DisputeKitClassic/DisputeKitClassic";
-import { Answer, ClassicRound } from "../../generated/schema";
+import { Answer, ClassicRound, Dispute, Round } from "../../generated/schema";
 import { ZERO } from "../utils";
 
-export function createClassicRound(disputeID: string, numberOfChoices: BigInt, roundIndex: BigInt): void {
-  const localDisputeID = `1-${disputeID}`;
+export function createClassicRound(
+  disputeID: string,
+  numberOfChoices: BigInt,
+  roundIndex: BigInt,
+  disputeKitID: string
+): void {
+  const localDisputeID = `${disputeKitID}-${disputeID}`;
   const id = `${localDisputeID}-${roundIndex.toString()}`;
   const classicRound = new ClassicRound(id);
   classicRound.localDispute = localDisputeID;
@@ -67,9 +72,16 @@ export function updateCountsAndGetCurrentRuling(id: string, choice: BigInt, delt
 }
 
 export function updateChoiceFundingFromContributionEvent(event: Contribution): void {
-  const disputeKitID = "1";
   const coreDisputeID = event.params._coreDisputeID.toString();
   const coreRoundIndex = event.params._coreRoundID.toString();
+  const coreDispute = Dispute.load(coreDisputeID);
+  if (!coreDispute) return;
+
+  const roundId = `${coreDisputeID}-${coreRoundIndex}`;
+  const coreRound = Round.load(roundId);
+  if (!coreRound) return;
+  const disputeKitID = coreRound.disputeKit;
+
   const roundID = `${disputeKitID}-${coreDisputeID}-${coreRoundIndex}`;
 
   const classicRound = ClassicRound.load(roundID);

subgraph/core/src/utils.ts

@@ -1,4 +1,10 @@
-import { BigInt } from "@graphprotocol/graph-ts";
+import { BigInt, Bytes } from "@graphprotocol/graph-ts";
 
 export const ZERO = BigInt.fromI32(0);
 export const ONE = BigInt.fromI32(1);
+
+export function extractDisputeKitIDFromExtraData(extraData: Bytes): string {
+  const start = extraData.length - 32;
+  const littleEndian = extraData.subarray(start, extraData.length).reverse();
+  return BigInt.fromUnsignedBytes(Bytes.fromUint8Array(littleEndian)).toString();
+}

subgraph/core/subgraph.yaml

@@ -120,6 +120,42 @@ dataSources:
         - event: CommitCast(indexed uint256,indexed address,uint256[],bytes32)
           handler: handleCommitCast
       file: ./src/DisputeKitClassic.ts
+  - kind: ethereum
+    name: DisputeKitShutter
+    network: arbitrum-sepolia
+    source:
+      address: "0x09F3d00B995186D76Af9AA8627D06351d0d9f950"
+      abi: DisputeKitShutter
+      startBlock: 148194178
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - ClassicDispute
+        - ClassicRound
+        - ClassicVote
+        - ClassicContribution
+      abis:
+        - name: DisputeKitShutter
+          file: ../../contracts/deployments/arbitrumSepoliaDevnet/DisputeKitShutter.json
+        - name: KlerosCore
+          # FIX: temporarily point to abi with event addition
+          file: ./abi-migrations/KlerosCore.json
+      eventHandlers:
+        - event: DisputeCreation(indexed uint256,uint256,bytes)
+          handler: handleDisputeCreation
+        - event: Contribution(indexed uint256,indexed uint256,uint256,indexed address,uint256)
+          handler: handleContributionEvent
+        - event: Withdrawal(indexed uint256,indexed uint256,uint256,indexed address,uint256)
+          handler: handleWithdrawal
+        - event: ChoiceFunded(indexed uint256,indexed uint256,indexed uint256)
+          handler: handleChoiceFunded
+        - event: VoteCast(indexed uint256,indexed address,uint256[],indexed uint256,string)
+          handler: handleVoteCast
+        - event: CommitCast(indexed uint256,indexed address,uint256[],bytes32)
+          handler: handleCommitCast
+      file: ./src/DisputeKitClassic.ts
   - kind: ethereum
     name: EvidenceModule
     network: arbitrum-sepolia

subgraph/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kleros/kleros-v2-subgraph",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "drtVersion": "0.12.0",
   "license": "MIT",
   "scripts": {