feat(subgraph): dispute-archive-mapping

Author: tractorss

bots/dispute-archival-bot/abi/DisputeArchive.ts

@@ -33,6 +33,12 @@ export const disputeArchiveAbi = [
         name: "id",
         type: "uint256",
       },
+      {
+        indexed: false,
+        internalType: "uint96",
+        name: "courtId",
+        type: "uint96",
+      },
       {
         indexed: false,
         internalType: "string",
@@ -130,6 +136,11 @@ export const disputeArchiveAbi = [
         name: "id",
         type: "uint256",
       },
+      {
+        internalType: "uint96",
+        name: "courtId",
+        type: "uint96",
+      },
       {
         internalType: "string",
         name: "cid",

bots/dispute-archival-bot/index.ts

@@ -26,7 +26,9 @@ async function main() {
 
     const cid = await uploadToIpfs(id, snapshot);
 
-    const hash = await registerCid(id, cid);
+    const courtID = snapshot.dispute.court.id;
+
+    const hash = await registerCid(id, courtID, cid);
 
     console.log(`Dispute ${id} archived with cid: ${cid}. Transaction hash: ${hash}`);
   }

bots/dispute-archival-bot/utils/contract.ts

@@ -27,7 +27,7 @@ const getClients = () => {
   };
 };
 
-export async function registerCid(disputeId: string, cid: string) {
+export async function registerCid(disputeId: string, courtId: string, cid: string) {
   const { publicClient, walletClient, account } = getClients();
   const config = getEnvConfig();
 
@@ -36,7 +36,7 @@ export async function registerCid(disputeId: string, cid: string) {
     address: config.disputeArchiveAddress as Address,
     abi: disputeArchiveAbi,
     functionName: "register",
-    args: [BigInt(disputeId), cid],
+    args: [BigInt(disputeId), BigInt(courtId), cid],
   });
 
   const hash = await walletClient.writeContract(request);

contracts/deployments/arbitrumSepoliaDevnet/DisputeArchive.json

@@ -10,9 +10,10 @@ contract DisputeArchive {
 
     /**
      * @param id Id of the archived dispute
+     * @param courtId Id of the court in which the dispute initiated
      * @param cid Ipfs cid containing the populated dispute + dispute evidences + kleros core subgraph data
      */
-    event ArchivedDispute(uint256 indexed id, string cid);
+    event ArchivedDispute(uint256 indexed id, uint96 courtId, string cid);
 
     /**
      * @param id Id of the amended archived dispute
@@ -61,13 +62,14 @@ contract DisputeArchive {
 
     /// @notice Stores archived dispute's ipfs cid.
     /// @param id ID of dispute to be archived.
+    /// @param courtId Id of the court in which the dispute initiated
     /// @param cid Archived dispute data's ipfs cid.
-    function register(uint256 id, string calldata cid) external onlyOwner {
+    function register(uint256 id, uint96 courtId, string calldata cid) external onlyOwner {
         require(bytes(archivedDisputeToCid[id]).length == 0, DisputeAlreadyArchived());
         require(bytes(cid).length > 0, CIDCannotBeEmpty());
 
         archivedDisputeToCid[id] = cid;
-        emit ArchivedDispute(id, cid);
+        emit ArchivedDispute(id, courtId, cid);
     }
 
     /// @notice Amends archived dispute's ipfs cid.

contracts/src/archive/DisputeArchive.sol

@@ -185,6 +185,8 @@ type Dispute @entity(immutable: false) {
   # required to keep evidence unique
   evidenceCount: BigInt!
   evidences: [ClassicEvidence!]! @derivedFrom(field: "dispute")
+  isArchived: Boolean!
+  archiveCid: String
 }
 
 type PeriodIndexCounter @entity(immutable: false) {

subgraph/core/schema.graphql

@@ -0,0 +1,51 @@
+import { BigInt, Bytes, log } from "@graphprotocol/graph-ts";
+import { ArchivedDispute, ArchivedDisputeAmended } from "../generated/DisputeArchive/DisputeArchive";
+import { Dispute } from "../generated/schema";
+import { createArchiveOnlyDispute } from "./archive/disputeArchiveStubs";
+import { ONE } from "./utils";
+
+function createArchiveDispute(
+  disputeId: BigInt,
+  courtId: BigInt,
+  cid: string,
+  reason: string | null,
+  timestamp: BigInt,
+  blockNumber: BigInt,
+  transactionHash: Bytes
+): void {
+  const dispute = Dispute.load(disputeId.toString());
+
+  // if dispute is present, then it is an amend event
+  if (dispute) {
+    dispute.isArchived = true;
+    dispute.archiveCid = cid;
+    dispute.save();
+    return;
+  }
+
+  createArchiveOnlyDispute(disputeId, courtId, cid, reason, timestamp, blockNumber, transactionHash);
+}
+
+export function handleDisputeArchived(event: ArchivedDispute): void {
+  createArchiveDispute(
+    event.params.id,
+    event.params.courtId,
+    event.params.cid,
+    null,
+    event.block.timestamp,
+    event.block.number,
+    event.transaction.hash
+  );
+}
+
+export function handleDisputeAmended(event: ArchivedDisputeAmended): void {
+  createArchiveDispute(
+    event.params.id,
+    ONE, // this is placeholder, will not be used
+    event.params.cid,
+    event.params.reason,
+    event.block.timestamp,
+    event.block.number,
+    event.transaction.hash
+  );
+}

subgraph/core/src/DisputeArchive.ts

@@ -0,0 +1,101 @@
+import { BigInt, Bytes } from "@graphprotocol/graph-ts";
+import { Arbitrable, Court, Dispute, DisputeKit, Round } from "../../generated/schema";
+import { ONE, ZERO } from "../utils";
+import { updateCases, updateCasesRuled, updateCourtCumulativeMetric } from "../datapoint";
+
+const ARCHIVE_STUB_DISPUTE_KIT_ID = "archive-stub-dispute-kit";
+const ARCHIVE_STUB_ARBITRABLE_ID = "0x0000000000000000000000000000000000000000";
+
+function ensureArchiveStubDisputeKit(): void {
+  if (DisputeKit.load(ARCHIVE_STUB_DISPUTE_KIT_ID) != null) {
+    return;
+  }
+  const disputeKit = new DisputeKit(ARCHIVE_STUB_DISPUTE_KIT_ID);
+  disputeKit.address = null;
+  disputeKit.needsFreezing = false;
+  disputeKit.save();
+}
+
+function ensureArchiveStubArbitrable(): void {
+  if (Arbitrable.load(ARCHIVE_STUB_ARBITRABLE_ID) != null) {
+    return;
+  }
+  const arbitrable = new Arbitrable(ARCHIVE_STUB_ARBITRABLE_ID);
+  arbitrable.totalDisputes = ZERO;
+  arbitrable.save();
+}
+
+// creates placeholder entities
+export function ensureArchiveStubEntities(): void {
+  ensureArchiveStubDisputeKit();
+  ensureArchiveStubArbitrable();
+}
+
+export function createArchiveOnlyDispute(
+  disputeId: BigInt,
+  courtId: BigInt,
+  cid: string,
+  reason: string | null,
+  blockTimestamp: BigInt,
+  blockNumber: BigInt,
+  transactionHash: Bytes
+): void {
+  ensureArchiveStubEntities();
+  updateCases(ONE, blockTimestamp);
+  updateCasesRuled(ONE, blockTimestamp);
+
+  // placeholder for currentRound, actual data is fetched from ipfs
+  const currentRoundId = disputeId.toString() + "-0";
+  const currentRound = Round.load(currentRoundId);
+
+  if (!currentRound) {
+    const round = new Round(currentRoundId);
+    round.dispute = disputeId.toString();
+    round.court = courtId.toString();
+    round.disputeKit = ARCHIVE_STUB_DISPUTE_KIT_ID;
+    round.tokensAtStakePerJuror = ZERO;
+    round.totalFeesForJurors = ZERO;
+    round.nbVotes = ZERO;
+    round.isCurrentRound = true;
+    round.repartitions = ZERO;
+    round.penalties = ZERO;
+    round.timeline = [ZERO, ZERO, ZERO, ZERO];
+    round.jurorsDrawn = false;
+    round.jurorRewardsDispersed = false;
+    round.timesPerPeriod = [ZERO, ZERO, ZERO, ZERO];
+    round.hiddenVotes = false;
+    round.jurorsForCourtJump = ZERO;
+    round.feeToken = null;
+    round.save();
+  }
+
+  const dispute = new Dispute(disputeId.toString());
+  dispute.disputeID = disputeId;
+  dispute.court = courtId.toString();
+  dispute.createdAt = blockTimestamp;
+  dispute.transactionHash = transactionHash.toHexString();
+  dispute.arbitrated = ARCHIVE_STUB_ARBITRABLE_ID;
+  dispute.period = "execution";
+  dispute.ruled = true;
+  dispute.executed = true;
+  dispute.currentRuling = ZERO;
+  dispute.tied = false;
+  dispute.overridden = false;
+  dispute.periodDeadline = blockTimestamp;
+  dispute.periodNotificationIndex = ZERO;
+  dispute.lastPeriodChange = blockTimestamp;
+  dispute.lastPeriodChangeBlockNumber = blockNumber;
+  dispute.currentRound = currentRoundId;
+  dispute.currentRoundIndex = ZERO;
+  dispute.evidenceCount = ZERO;
+  dispute.isArchived = true;
+  dispute.archiveCid = cid;
+  dispute.save();
+
+  const court = Court.load(courtId.toString());
+  if (!court) return;
+  court.numberDisputes = court.numberDisputes.plus(ONE);
+  // archived dispute is closed already
+  court.numberClosedDisputes = court.numberClosedDisputes.plus(ONE);
+  updateCourtCumulativeMetric(courtId.toString(), ONE, blockTimestamp, "numberDisputes");
+}

subgraph/core/src/archive/disputeArchiveStubs.ts

@@ -24,6 +24,8 @@ export function createDisputeFromEvent(event: DisputeCreation): void {
   dispute.periodNotificationIndex = getAndIncrementPeriodCounter(dispute.period);
   dispute.transactionHash = event.transaction.hash.toHexString();
   dispute.evidenceCount = ZERO;
+  dispute.isArchived = false;
+  dispute.archiveCid = null;
   const court = Court.load(courtID);
   if (!court) return;
   // Note: It's okay to use `timesPerPeriod` from court here since, at this point, both are the same.

subgraph/core/src/entities/Dispute.ts

@@ -390,3 +390,29 @@ dataSources:
         - event: NewCurrencyRate(indexed address,uint64,uint8)
           handler: handleNewCurrencyRate
       file: ./src/RatesConverter.ts
+  - kind: ethereum
+    name: DisputeArchive
+    network: _PLACEHOLDER_
+    source:
+      address: "_PLACEHOLDER_"
+      abi: DisputeArchive
+      startBlock: _PLACEHOLDER_
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Arbitrable
+        - Court
+        - DisputeKit
+        - Dispute
+        - Round
+      abis:
+        - name: DisputeArchive
+          file: ../../contracts/deployments/_PLACEHOLDER_/DisputeArchive.json
+      eventHandlers:
+        - event: ArchivedDispute(indexed uint256,uint96,string)
+          handler: handleDisputeArchived
+        - event: ArchivedDisputeAmended(indexed uint256,string,string)
+          handler: handleDisputeAmended
+      file: ./src/DisputeArchive.ts