fix: got the subgraph build to pass but some fixes are still required

Author: jaybuidl

subgraph/core/schema.graphql

@@ -74,7 +74,7 @@ type User @entity {
   tokens: [JurorTokensPerCourt!]! @derivedFrom(field: "juror")
   totalStake: BigInt!
   totalDelayed: BigInt!
-  shifts: [TokenAndETHShift!]! @derivedFrom(field: "juror")
+  shifts: [JurorRewardPenalty!]! @derivedFrom(field: "juror")
   draws: [Draw!]! @derivedFrom(field: "juror")
   activeDisputes: BigInt!
   rounds: [Round!]!
@@ -99,7 +99,8 @@ type Penalty @entity {
   juror: User!
   amount: BigInt!
   numberDraws: BigInt!
-  degreeOfCoherency: BigInt!
+  degreeOfCoherencyPnk: BigInt!
+  degreeOfCoherencyFee: BigInt!
 }
 
 type Arbitrable @entity {
@@ -108,7 +109,7 @@ type Arbitrable @entity {
   totalDisputes: BigInt!
 }
 
-type TokenAndETHShift @entity {
+type JurorRewardPenalty @entity {
   id: ID! # user.id-dispute.id
   juror: User!
   dispute: Dispute!
@@ -178,7 +179,7 @@ type Dispute @entity {
   currentRound: Round!
   currentRoundIndex: BigInt!
   jurors: [User!]! @derivedFrom(field: "disputes")
-  shifts: [TokenAndETHShift!]! @derivedFrom(field: "dispute")
+  shifts: [JurorRewardPenalty!]! @derivedFrom(field: "dispute")
   disputeKitDispute: [DisputeKitDispute!]! @derivedFrom(field: "coreDispute")
   isCrossChain: Boolean
   arbitrableChainId:BigInt
@@ -260,7 +261,7 @@ type FeeToken @entity {
   totalPaid: BigInt!
   totalPaidInETH: BigInt!
   rounds: [Round!] @derivedFrom(field: "feeToken")
-  tokenAndETHShift: [TokenAndETHShift!] @derivedFrom(field: "feeToken")
+  jurorRewardPenalty: [JurorRewardPenalty!] @derivedFrom(field: "feeToken")
 }
 
 #####################

subgraph/core/src/DisputeKitClassic.ts

@@ -181,7 +181,9 @@ 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();
+
+  // TODO: handle the removal of _coreRoundID from the event
+  const coreRoundIndex = 0; // event.params._coreRoundID.toString();
 
   const coreDispute = Dispute.load(coreDisputeID);
   if (!coreDispute) return;

subgraph/core/src/EvidenceModule.ts

@@ -7,7 +7,10 @@ import { ONE } from "./utils";
 import { JSONValueToMaybeString } from "../../utils";
 
 export function handleEvidenceEvent(event: EvidenceEvent): void {
-  const evidenceGroupID = event.params._externalDisputeID.toString();
+  // TODO: handle the replacement of _externalDisputeID with _arbitratorDisputeID
+  // TODO: no more evidenceGroupID
+  const evidenceGroupID = event.params._arbitratorDisputeID.toString();
+
   const evidenceGroup = ensureClassicEvidenceGroup(evidenceGroupID);
   const evidenceIndex = evidenceGroup.nextEvidenceIndex;
   evidenceGroup.nextEvidenceIndex = evidenceGroup.nextEvidenceIndex.plus(ONE);

subgraph/core/src/KlerosCore.ts

@@ -8,7 +8,7 @@ import {
   CourtModified,
   Draw as DrawEvent,
   NewPeriod,
-  TokenAndETHShift as TokenAndETHShiftEvent,
+  JurorRewardPenalty as JurorRewardPenaltyEvent,
   CourtJump,
   Ruling,
   AcceptedFeeToken,
@@ -29,7 +29,7 @@ import {
 import { addUserActiveDispute, computeCoherenceScore, ensureUser } from "./entities/User";
 import { updateJurorStake } from "./entities/JurorTokensPerCourt";
 import { createDrawFromEvent } from "./entities/Draw";
-import { updateTokenAndEthShiftFromEvent } from "./entities/TokenAndEthShift";
+import { updateJurorRewardPenaltyEvent } from "./entities/JurorRewardPenalty";
 import { updateArbitrableCases } from "./entities/Arbitrable";
 import { ClassicVote, Court, Dispute, Draw, Round, User } from "../generated/schema";
 import { BigInt } from "@graphprotocol/graph-ts";
@@ -277,9 +277,9 @@ export function handleDraw(event: DrawEvent): void {
   }
 }
 
-export function handleTokenAndETHShift(event: TokenAndETHShiftEvent): void {
+export function handleJurorRewardPenalty(event: JurorRewardPenaltyEvent): void {
   updatePenalty(event);
-  updateTokenAndEthShiftFromEvent(event);
+  updateJurorRewardPenaltyEvent(event);
   const jurorAddress = event.params._account.toHexString();
   const disputeID = event.params._disputeID.toString();
   const dispute = Dispute.load(disputeID);

subgraph/core/src/entities/ClassicContribution.ts

@@ -1,11 +1,13 @@
-import { ClassicContribution, Dispute, DisputeKit, Round } from "../../generated/schema";
+import { ClassicContribution, Dispute, Round } from "../../generated/schema";
 import { Contribution as ContributionEvent, Withdrawal } from "../../generated/DisputeKitClassic/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();
+
+  // TODO: handle the removal of _coreRoundID from the event
+  const coreRoundIndex = 0; // event.params._coreRoundID.toString();
 
   const coreDispute = Dispute.load(coreDisputeID);
   if (!coreDispute) return null;

subgraph/core/src/entities/TokenAndEthShift.ts renamed to subgraph/core/src/entities/JurorRewardPenalty.ts

@@ -1,12 +1,12 @@
 import { Address, BigInt } from "@graphprotocol/graph-ts";
-import { TokenAndETHShift as TokenAndETHShiftEvent } from "../../generated/KlerosCore/KlerosCore";
-import { Court, Dispute, TokenAndETHShift } from "../../generated/schema";
+import { JurorRewardPenalty as JurorRewardPenaltyEvent } from "../../generated/KlerosCore/KlerosCore";
+import { Court, Dispute, JurorRewardPenalty } from "../../generated/schema";
 import { updatePaidETH, updateRedistributedPNK } from "../datapoint";
 import { ZERO } from "../utils";
 import { convertTokenAmountToEth, updateFeeTokenPaid } from "./FeeToken";
 import { resolveUserDispute } from "./User";
 
-export function updateTokenAndEthShiftFromEvent(event: TokenAndETHShiftEvent): void {
+export function updateJurorRewardPenaltyEvent(event: JurorRewardPenaltyEvent): void {
   const jurorAddress = event.params._account;
   const disputeID = event.params._disputeID;
   const dispute = Dispute.load(disputeID.toString());
@@ -16,8 +16,8 @@ export function updateTokenAndEthShiftFromEvent(event: TokenAndETHShiftEvent): v
   const roundIndex = event.params._roundID;
   const feeTokenAddress = event.params._feeToken;
   let shift = ensureTokenAndEthShift(jurorAddress, disputeID, roundIndex, feeTokenAddress);
-  const feeAmount = event.params._feeAmount;
-  const pnkAmount = event.params._pnkAmount;
+  const feeAmount = event.params._amountFee;
+  const pnkAmount = event.params._amountPnk;
   let ethAmount: BigInt;
   if (feeTokenAddress.toHexString() === "0x0000000000000000000000000000000000000000") {
     updateFeeTokenPaid(feeTokenAddress, event.address, feeAmount);
@@ -46,11 +46,11 @@ export function ensureTokenAndEthShift(
   disputeID: BigInt,
   roundIndex: BigInt,
   feeTokenAddress: Address
-): TokenAndETHShift {
+): JurorRewardPenalty {
   const shiftID = `${jurorAddress.toHexString()}-${disputeID.toString()}-${roundIndex.toString()}`;
-  let shift = TokenAndETHShift.load(shiftID);
+  let shift = JurorRewardPenalty.load(shiftID);
   if (!shift) {
-    shift = new TokenAndETHShift(shiftID);
+    shift = new JurorRewardPenalty(shiftID);
     if (feeTokenAddress !== Address.fromI32(0)) {
       shift.isNativeCurrency = false;
       shift.feeToken = feeTokenAddress.toHexString();

subgraph/core/src/entities/Penalty.ts

@@ -1,26 +1,27 @@
-import { TokenAndETHShift } from "../../generated/KlerosCore/KlerosCore";
+import { JurorRewardPenalty } from "../../generated/KlerosCore/KlerosCore";
 import { Penalty } from "../../generated/schema";
 import { ONE } from "../utils";
 
-export function updatePenalty(event: TokenAndETHShift): void {
+export function updatePenalty(event: JurorRewardPenalty): void {
   const disputeID = event.params._disputeID.toString();
   const roundIndex = event.params._roundID.toString();
   const roundID = `${disputeID}-${roundIndex}`;
   const jurorAddress = event.params._account.toHexString();
   const penaltyID = `${roundID}-${jurorAddress}`;
   const penalty = Penalty.load(penaltyID);
   if (penalty) {
-    penalty.amount = penalty.amount.plus(event.params._pnkAmount);
-    const totalCoherency = penalty.degreeOfCoherency.times(penalty.numberDraws);
+    penalty.amount = penalty.amount.plus(event.params._amountPnk);
+    const totalCoherency = penalty.degreeOfCoherencyPnk.times(penalty.numberDraws);
     penalty.numberDraws = penalty.numberDraws.plus(ONE);
-    penalty.degreeOfCoherency = totalCoherency.plus(penalty.degreeOfCoherency).div(penalty.numberDraws);
+    penalty.degreeOfCoherencyPnk = totalCoherency.plus(penalty.degreeOfCoherencyPnk).div(penalty.numberDraws);
+    // TODO: handle _degreeOfCoherencyFee
     penalty.save();
   } else {
     createPenalty(event);
   }
 }
 
-export function createPenalty(event: TokenAndETHShift): void {
+export function createPenalty(event: JurorRewardPenalty): void {
   const disputeID = event.params._disputeID.toString();
   const roundIndex = event.params._roundID.toString();
   const roundID = `${disputeID}-${roundIndex}`;
@@ -31,7 +32,8 @@ export function createPenalty(event: TokenAndETHShift): void {
   penalty.round = roundID;
   penalty.juror = jurorAddress;
   penalty.numberDraws = ONE;
-  penalty.amount = event.params._pnkAmount;
-  penalty.degreeOfCoherency = event.params._degreeOfCoherency;
+  penalty.amount = event.params._amountPnk;
+  penalty.degreeOfCoherencyPnk = event.params._degreeOfCoherencyPnk;
+  penalty.degreeOfCoherencyFee = event.params._degreeOfCoherencyFee;
   penalty.save();
 }