Feat(web, subgraph): Performance improvements, code refactor, subgraph add FeeToken

bot-pinner/README.md

@@ -17,6 +17,7 @@ $ docker-compose up -d
 2. Evidence container that awaits new events and then scrapes the latest hashes and submits it to IPFS.
 3. `src/peers.txt` contains a list of peers, by default it will add connects to Estuary & Kleros IPFS nodes. This should make it easier to find content by creating a data network around Kleros Court V2.
    1. Adding these peers will make it easier to find and replicate content.
+
 ## DappNode
 
 :warning: For the following steps, you need access to [a DappNode](https://dappnode.io) system with the IPFS service running.

contracts/scripts/simulations/tasks.ts

@@ -268,7 +268,7 @@ task("simulate:cast-commit", "Casts a commit for a drawn juror")
     const tx = await disputeKitClassic.connect(wallet).castCommit(...castCommitFunctionArgs);
     await tx.wait();
 
-    console.log("juror %s casted a commit on txID: %s", wallet.address, tx?.hash);
+    console.log("juror %s cast a commit on txID: %s", wallet.address, tx?.hash);
   });
 
 task("simulate:cast-vote", "Casts a vote for a drawn juror")
@@ -295,7 +295,7 @@ task("simulate:cast-vote", "Casts a vote for a drawn juror")
     const tx = await disputeKitClassic.connect(wallet).castVote(...castVoteFunctionArgs);
     await tx.wait();
 
-    console.log("juror %s casted a vote on txID: %s", wallet.address, tx?.hash);
+    console.log("juror %s cast a vote on txID: %s", wallet.address, tx?.hash);
   });
 
 task("simulate:fund-appeal", "Funds an appeal on a dispute")

subgraph/schema.graphql

@@ -96,8 +96,11 @@ type TokenAndETHShift @entity {
   id: ID! # user.id-dispute.id
   juror: User!
   dispute: Dispute!
-  tokenAmount: BigInt!
+  pnkAmount: BigInt!
   ethAmount: BigInt!
+  isNativeCurrency: Boolean!
+  feeTokenAmount: BigInt!
+  feeToken: FeeToken
 }
 
 type JurorTokensPerCourt @entity {
@@ -159,6 +162,7 @@ type Round @entity {
   penalties: BigInt!
   drawnJurors: [Draw!]! @derivedFrom(field: "round")
   dispute: Dispute!
+  feeToken: FeeToken
 }
 
 type Draw @entity {
@@ -191,6 +195,17 @@ type Counter @entity {
   casesRuled: BigInt!
 }
 
+type FeeToken @entity {
+  id: ID! # The address of the ERC20 token.
+  accepted: Boolean!
+  rateInEth: BigInt!
+  rateDecimals: Int!
+  totalPaid: BigInt!
+  totalPaidInETH: BigInt!
+  rounds: [Round!] @derivedFrom(field: "feeToken")
+  tokenAndETHShift: [TokenAndETHShift!] @derivedFrom(field: "feeToken")
+}
+
 #####################
 # ClassicDisputeKit #
 #####################

subgraph/src/DisputeKitClassic.ts

@@ -47,13 +47,17 @@ export function handleEvidenceEvent(event: EvidenceEvent): void {
 }
 
 export function handleJustificationEvent(event: JustificationEvent): void {
-  const coreDisputeID = event.params._coreDisputeID.toString();
-  const coreDispute = Dispute.load(coreDisputeID);
+  const contract = DisputeKitClassic.bind(event.address);
+  const coreDisputeID = event.params._coreDisputeID;
+  const coreDispute = Dispute.load(coreDisputeID.toString());
   const classicDisputeID = `${DISPUTEKIT_ID}-${coreDisputeID}`;
   const classicDispute = ClassicDispute.load(classicDisputeID);
   if (!classicDispute || !coreDispute) return;
+  const choice = event.params._choice;
+  const coreRoundIndex = coreDispute.currentRoundIndex;
+  const roundInfo = contract.getRoundInfo(coreDisputeID, coreRoundIndex, choice);
   const currentLocalRoundID = classicDispute.id + "-" + classicDispute.currentLocalRoundIndex.toString();
-  const currentRulingInfo = updateCountsAndGetCurrentRuling(currentLocalRoundID, event.params._choice);
+  const currentRulingInfo = updateCountsAndGetCurrentRuling(currentLocalRoundID, choice, roundInfo.getChoiceCount());
   coreDispute.currentRuling = currentRulingInfo.ruling;
   coreDispute.tied = currentRulingInfo.tied;
   coreDispute.save();

subgraph/src/KlerosCore.ts

@@ -12,21 +12,23 @@ import {
   TokenAndETHShift as TokenAndETHShiftEvent,
   Ruling,
   StakeDelayed,
+  AcceptedFeeToken,
 } from "../generated/KlerosCore/KlerosCore";
 import { ZERO, ONE } from "./utils";
 import { createCourtFromEvent, getFeeForJuror } from "./entities/Court";
 import { createDisputeKitFromEvent, filterSupportedDisputeKits } from "./entities/DisputeKit";
 import { createDisputeFromEvent } from "./entities/Dispute";
 import { createRoundFromRoundInfo } from "./entities/Round";
-import { updateCases, updatePaidETH, updateRedistributedPNK, updateCasesRuled, updateCasesVoting } from "./datapoint";
+import { updateCases, updateCasesRuled, updateCasesVoting } from "./datapoint";
 import { addUserActiveDispute, ensureUser } from "./entities/User";
 import { updateJurorDelayedStake, updateJurorStake } from "./entities/JurorTokensPerCourt";
 import { createDrawFromEvent } from "./entities/Draw";
 import { updateTokenAndEthShiftFromEvent } from "./entities/TokenAndEthShift";
 import { updateArbitrableCases } from "./entities/Arbitrable";
-import { Court, Dispute } from "../generated/schema";
+import { Court, Dispute, FeeToken } from "../generated/schema";
 import { BigInt } from "@graphprotocol/graph-ts";
 import { updatePenalty } from "./entities/Penalty";
+import { ensureFeeToken } from "./entities/FeeToken";
 
 function getPeriodName(index: i32): string {
   const periodArray = ["evidence", "commit", "vote", "appeal", "execution"];
@@ -156,22 +158,17 @@ export function handleStakeDelayed(event: StakeDelayed): void {
 }
 
 export function handleTokenAndETHShift(event: TokenAndETHShiftEvent): void {
+  updatePenalty(event);
   updateTokenAndEthShiftFromEvent(event);
   const jurorAddress = event.params._account.toHexString();
   const disputeID = event.params._disputeID.toString();
-  const pnkAmount = event.params._pnkAmount;
-  const feeAmount = event.params._feeAmount;
   const dispute = Dispute.load(disputeID);
   if (!dispute) return;
   const court = Court.load(dispute.court);
   if (!court) return;
   updateJurorStake(jurorAddress, court.id, KlerosCore.bind(event.address), event.block.timestamp);
-  court.paidETH = court.paidETH.plus(feeAmount);
-  if (pnkAmount.gt(ZERO)) {
-    court.paidPNK = court.paidPNK.plus(pnkAmount);
-    updateRedistributedPNK(pnkAmount, event.block.timestamp);
-  }
-  updatePaidETH(feeAmount, event.block.timestamp);
-  updatePenalty(event);
-  court.save();
+}
+
+export function handleAcceptedFeeToken(event: AcceptedFeeToken): void {
+  ensureFeeToken(event.params._token, event.address);
 }

subgraph/src/entities/ClassicRound.ts

@@ -25,15 +25,15 @@ class CurrentRulingInfo {
   tied: boolean;
 }
 
-export function updateCountsAndGetCurrentRuling(id: string, choice: BigInt): CurrentRulingInfo {
+export function updateCountsAndGetCurrentRuling(id: string, choice: BigInt, choiceCount: BigInt): CurrentRulingInfo {
   const round = ClassicRound.load(id);
   if (!round) return { ruling: ZERO, tied: false };
   const choiceNum = choice.toI32();
-  const updatedCount = round.counts[choiceNum].plus(ONE);
+  const delta = choiceCount.minus(round.counts[choiceNum]);
   let newCounts: BigInt[] = [];
   for (let i = 0; i < round.counts.length; i++) {
     if (BigInt.fromI32(i).equals(choice)) {
-      newCounts.push(round.counts[i].plus(ONE));
+      newCounts.push(choiceCount);
     } else {
       newCounts.push(round.counts[i]);
     }
@@ -43,14 +43,14 @@ export function updateCountsAndGetCurrentRuling(id: string, choice: BigInt): Cur
   if (choice.equals(round.winningChoice)) {
     if (round.tied) round.tied = false;
   } else {
-    if (updatedCount.equals(currentWinningCount)) {
+    if (choiceCount.equals(currentWinningCount)) {
       if (!round.tied) round.tied = true;
-    } else if (updatedCount.gt(currentWinningCount)) {
+    } else if (choiceCount.gt(currentWinningCount)) {
       round.winningChoice = choice;
       round.tied = false;
     }
   }
-  round.totalVoted = round.totalVoted.plus(ONE);
+  round.totalVoted = round.totalVoted.plus(delta);
   round.save();
   return { ruling: round.winningChoice, tied: round.tied };
 }

subgraph/src/entities/FeeToken.ts

@@ -0,0 +1,53 @@
+import { BigInt, Address } from "@graphprotocol/graph-ts";
+import { FeeToken } from "../../generated/schema";
+import { KlerosCore } from "../../generated/KlerosCore/KlerosCore";
+import { ZERO } from "../utils";
+
+export function ensureFeeToken(tokenAddress: Address, klerosCoreAddress: Address): FeeToken {
+  const hexTokenAddress = tokenAddress.toHexString();
+  let feeToken = FeeToken.load(hexTokenAddress);
+  if (!feeToken) {
+    feeToken = new FeeToken(hexTokenAddress);
+    feeToken.totalPaid = ZERO;
+    feeToken.totalPaidInETH = ZERO;
+  }
+  const contract = KlerosCore.bind(klerosCoreAddress);
+  const currencyRate = contract.currencyRates(tokenAddress);
+  feeToken.accepted = currencyRate.value0;
+  feeToken.rateInEth = currencyRate.value1;
+  feeToken.rateDecimals = currencyRate.value2;
+  feeToken.save();
+  return feeToken;
+}
+
+export function updateFeeTokenRate(tokenAddress: Address, klerosCoreAddress: Address): void {
+  const feeToken = ensureFeeToken(tokenAddress, klerosCoreAddress);
+  const contract = KlerosCore.bind(klerosCoreAddress);
+  const currencyRate = contract.currencyRates(tokenAddress);
+  feeToken.accepted = currencyRate.value0;
+  feeToken.rateInEth = currencyRate.value1;
+  feeToken.rateDecimals = currencyRate.value2;
+  feeToken.save();
+}
+
+export function updateFeeTokenPaid(tokenAddress: Address, klerosCoreAddress: Address, amount: BigInt): void {
+  const feeToken = ensureFeeToken(tokenAddress, klerosCoreAddress);
+  const ethAmount = convertTokenAmountToEth(tokenAddress, amount, klerosCoreAddress);
+  feeToken.totalPaid = feeToken.totalPaid.plus(amount);
+  feeToken.totalPaidInETH = feeToken.totalPaidInETH.plus(ethAmount);
+  feeToken.save();
+}
+
+export function convertEthToTokenAmount(tokenAddress: Address, eth: BigInt, klerosCoreAddress: Address): BigInt {
+  const feeToken = ensureFeeToken(tokenAddress, klerosCoreAddress);
+  return eth.times(BigInt.fromI32(10 ** feeToken.rateDecimals)).div(feeToken.rateInEth);
+}
+
+export function convertTokenAmountToEth(
+  tokenAddress: Address,
+  tokenAmount: BigInt,
+  klerosCoreAddress: Address
+): BigInt {
+  const feeToken = ensureFeeToken(tokenAddress, klerosCoreAddress);
+  return tokenAmount.times(feeToken.rateInEth).div(BigInt.fromI32(10 ** feeToken.rateDecimals));
+}

subgraph/src/entities/Round.ts

@@ -9,12 +9,15 @@ export function createRoundFromRoundInfo(
 ): void {
   const roundID = `${disputeID.toString()}-${roundIndex.toString()}`;
   const round = new Round(roundID);
+  const feeToken = roundInfo.getFeeToken();
   round.disputeKit = roundInfo.getDisputeKitID.toString();
   round.tokensAtStakePerJuror = roundInfo.getPnkAtStakePerJuror();
   round.totalFeesForJurors = roundInfo.getTotalFeesForJurors();
   round.nbVotes = roundInfo.getNbVotes();
   round.repartitions = roundInfo.getRepartitions();
   round.penalties = roundInfo.getPnkPenalties();
   round.dispute = disputeID.toString();
+  round.feeToken =
+    feeToken.toHexString() === "0x0000000000000000000000000000000000000000" ? null : feeToken.toHexString();
   round.save();
 }

subgraph/src/entities/TokenAndEthShift.ts

@@ -1,36 +1,68 @@
+import { Address, BigInt } from "@graphprotocol/graph-ts";
 import { TokenAndETHShift as TokenAndETHShiftEvent } from "../../generated/KlerosCore/KlerosCore";
-import { TokenAndETHShift } from "../../generated/schema";
+import { Court, Dispute, TokenAndETHShift } 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 {
-  const jurorAddress = event.params._account.toHexString();
-  const disputeID = event.params._disputeID.toString();
-  const shiftID = `${jurorAddress}-${disputeID}`;
-  const shift = TokenAndETHShift.load(shiftID);
-
-  if (!shift) {
-    createTokenAndEthShiftFromEvent(event);
-    resolveUserDispute(jurorAddress, ZERO, event.params._feeAmount, disputeID);
-    return;
+  const jurorAddress = event.params._account;
+  const disputeID = event.params._disputeID;
+  const dispute = Dispute.load(disputeID.toString());
+  if (!dispute) return;
+  const court = Court.load(dispute.court);
+  if (!court) return;
+  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;
+  let ethAmount: BigInt;
+  if (feeTokenAddress.toHexString() === "0x0000000000000000000000000000000000000000") {
+    updateFeeTokenPaid(feeTokenAddress, event.address, feeAmount);
+    ethAmount = convertTokenAmountToEth(feeTokenAddress, feeAmount, event.address);
+    shift.feeTokenAmount = shift.feeTokenAmount.plus(feeAmount);
+  } else {
+    ethAmount = feeAmount;
   }
-
-  shift.tokenAmount = shift.tokenAmount.plus(event.params._pnkAmount);
-  const previousFeeAmount = shift.ethAmount;
-  const newFeeAmount = shift.ethAmount.plus(event.params._feeAmount);
-  shift.ethAmount = newFeeAmount;
+  const previousEthAmount = shift.ethAmount;
+  const newEthAmount = previousEthAmount.plus(ethAmount);
+  shift.ethAmount = newEthAmount;
+  resolveUserDispute(jurorAddress.toHexString(), previousEthAmount, newEthAmount, disputeID.toString());
+  court.paidETH = court.paidETH.plus(ethAmount);
+  updatePaidETH(ethAmount, event.block.timestamp);
+  if (pnkAmount.gt(ZERO)) {
+    court.paidPNK = court.paidPNK.plus(pnkAmount);
+    updateRedistributedPNK(pnkAmount, event.block.timestamp);
+  }
+  shift.pnkAmount = shift.pnkAmount.plus(pnkAmount);
   shift.save();
-  resolveUserDispute(jurorAddress, previousFeeAmount, newFeeAmount, disputeID);
+  court.save();
 }
 
-export function createTokenAndEthShiftFromEvent(event: TokenAndETHShiftEvent): void {
-  const jurorAddress = event.params._account.toHexString();
-  const disputeID = event.params._disputeID.toString();
-  const shiftID = `${jurorAddress}-${disputeID}`;
-  const shift = new TokenAndETHShift(shiftID);
-  shift.juror = jurorAddress;
-  shift.dispute = disputeID;
-  shift.tokenAmount = event.params._pnkAmount;
-  shift.ethAmount = event.params._feeAmount;
-  shift.save();
+export function ensureTokenAndEthShift(
+  jurorAddress: Address,
+  disputeID: BigInt,
+  roundIndex: BigInt,
+  feeTokenAddress: Address
+): TokenAndETHShift {
+  const shiftID = `${jurorAddress.toHexString()}-${disputeID.toString()}-${roundIndex.toString()}`;
+  let shift = TokenAndETHShift.load(shiftID);
+  if (!shift) {
+    shift = new TokenAndETHShift(shiftID);
+    if (feeTokenAddress !== Address.fromI32(0)) {
+      shift.isNativeCurrency = false;
+      shift.feeToken = feeTokenAddress.toHexString();
+    } else {
+      shift.isNativeCurrency = true;
+    }
+    shift.feeTokenAmount = ZERO;
+    shift.ethAmount = ZERO;
+    shift.juror = jurorAddress.toHexString();
+    shift.dispute = disputeID.toString();
+    shift.pnkAmount = ZERO;
+    shift.save();
+  }
+  return shift;
 }

subgraph/subgraph.yaml

@@ -54,6 +54,8 @@ dataSources:
           handler: handleTokenAndETHShift
         - event: Ruling(indexed address,indexed uint256,uint256)
           handler: handleRuling
+        - event: AcceptedFeeToken(indexed address,indexed bool)
+          handler: handleAcceptedFeeToken
       file: ./src/KlerosCore.ts
   - kind: ethereum
     name: PolicyRegistry

web/.parcelrc

@@ -1,6 +1,8 @@
 {
   "extends": "@parcel/config-default",
   "transformers": {
-    "*.svg": ["...", "@parcel/transformer-svg-react"]
+    "*.svg": ["...", "@parcel/transformer-svg-react"],
+    "tsx:*.svg": ["@parcel/transformer-svg-react"],
+    "tsx:*": ["..."]
   }
 }

web/package.json

@@ -23,8 +23,7 @@
   },
   "packageManager": "[email protected]",
   "scripts": {
-    "clear": "rm -r .parcel-cache",
-    "clean": "rm dist/bundle.js",
+    "clear": "rm -fr ../.parcel-cache dist/bundle.js",
     "start": "parcel",
     "start-local": "REACT_APP_SUBGRAPH_ENDPOINT=http://localhost:8000/subgraphs/name/kleros/kleros-v2-core-local parcel",
     "build": "yarn generate && yarn parcel build",