feat: add argentina consumer protection dispute kit

subgraph/core/subgraph.template.yaml

@@ -228,6 +228,43 @@ dataSources:
         - event: CommitCast(indexed uint256,indexed address,uint256[],bytes32)
           handler: handleCommitCast
       file: ./src/DisputeKitClassic.ts
+  - kind: ethereum
+    name: DisputeKitGatedArgentinaConsumerProtection
+    network: _PLACEHOLDER_
+    source:
+      address: "_PLACEHOLDER_"
+      abi: DisputeKitGatedArgentinaConsumerProtection
+      startBlock: _PLACEHOLDER_
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - ClassicDispute
+        - ClassicRound
+        - ClassicVote
+        - ClassicContribution
+      abis:
+        - name: DisputeKitGatedArgentinaConsumerProtection
+          file: ../../contracts/deployments/_PLACEHOLDER_/DisputeKitGatedArgentinaConsumerProtection.json
+        - name: DisputeKitClassic # Required on Alchemy
+          file: ../../contracts/deployments/_PLACEHOLDER_/DisputeKitClassic.json
+        - name: KlerosCore
+          file: ../../contracts/deployments/_PLACEHOLDER_/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,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: _PLACEHOLDER_

web/src/components/DisputeFeatures/Features/ArgentinaConsumerProtection.tsx

@@ -0,0 +1,22 @@
+import React from "react";
+
+import { Features } from "consts/disputeFeature";
+
+import WithHelpTooltip from "components/WithHelpTooltip";
+
+import { RadioInput, StyledRadio } from ".";
+
+const ArgentinaConsumerProtection: React.FC<RadioInput> = (props) => {
+  return (
+    <WithHelpTooltip
+      tooltipMsg={`Jurors must hold either an accredited professional token or
+        an accredited consumer protection lawyer token to participate.
+        At least one drawn juror must hold the consumer protection lawyer token.`}
+      key={Features.ArgentinaConsumerProtection}
+    >
+      <StyledRadio label="Argentina Consumer Protection" small {...props} />
+    </WithHelpTooltip>
+  );
+};
+
+export default ArgentinaConsumerProtection;

web/src/components/DisputeFeatures/Features/index.tsx

@@ -7,6 +7,7 @@ import { Features } from "consts/disputeFeature";
 
 import WithHelpTooltip from "components/WithHelpTooltip";
 
+import ArgentinaConsumerProtection from "./ArgentinaConsumerProtection";
 import ClassicVote from "./ClassicVote";
 import GatedErc1155 from "./GatedErc1155";
 import GatedErc20 from "./GatedErc20";
@@ -30,8 +31,8 @@ export const StyledRadio = styled(Radio)`
 export const FeatureUIs: Record<Features, FeatureUI> = {
   [Features.ShieldedVote]: (props: RadioInput) => (
     <WithHelpTooltip
-      tooltipMsg={`The jurors votes are hidden. 
-        Nobody can see them before the voting period completes. 
+      tooltipMsg={`The jurors votes are hidden.
+        Nobody can see them before the voting period completes.
         It takes place in a single step via Shutter Network`}
       key={Features.ShieldedVote}
     >
@@ -48,4 +49,6 @@ export const FeatureUIs: Record<Features, FeatureUI> = {
   [Features.GatedErc20]: (props: RadioInput) => <GatedErc20 {...props} />,
 
   [Features.GatedErc1155]: (props: RadioInput) => <GatedErc1155 {...props} />,
+
+  [Features.ArgentinaConsumerProtection]: (props: RadioInput) => <ArgentinaConsumerProtection {...props} />,
 };

web/src/consts/disputeFeature.ts

@@ -11,6 +11,7 @@ export enum Features {
   ClassicEligibility = "classicEligibility",
   GatedErc20 = "gatedErc20",
   GatedErc1155 = "gatedErc1155",
+  ArgentinaConsumerProtection = "argentinaConsumerProtection",
 }
 
 /** Group of features (like radio buttons per category) */
@@ -38,7 +39,12 @@ export type DisputeKits = DisputeKit[];
 // DEV: the order of features in array , determine the order the radios appear on UI
 export const featureGroups: FeatureGroups = {
   [Group.Voting]: [Features.ClassicVote, Features.ShieldedVote],
-  [Group.Eligibility]: [Features.ClassicEligibility, Features.GatedErc20, Features.GatedErc1155],
+  [Group.Eligibility]: [
+    Features.ClassicEligibility,
+    Features.GatedErc20,
+    Features.GatedErc1155,
+    Features.ArgentinaConsumerProtection,
+  ],
 };
 
 // dispute kits
@@ -67,6 +73,11 @@ export const disputeKits: DisputeKits = [
     ],
     type: "gated",
   },
+  {
+    id: 5,
+    featureSets: [[Features.ClassicVote, Features.ArgentinaConsumerProtection]],
+    type: "general",
+  },
 ];
 
 /** Canonical string for a feature set (order-independent) */

web/src/consts/index.ts

@@ -47,4 +47,5 @@ export enum DisputeKits {
   Shutter = "Shutter",
   Gated = "Token Gated",
   GatedShutter = "Token Gated Shutter",
+  ArgentinaConsumerProtection = "Argentina Consumer Protection",
 }

web/src/hooks/useDisputeKitAddresses.ts

@@ -19,6 +19,7 @@ const DISPUTE_KIT_CONFIG = {
   [DisputeKits.Shutter]: "disputeKitShutterAddress",
   [DisputeKits.Gated]: "disputeKitGatedAddress",
   [DisputeKits.GatedShutter]: "disputeKitGatedShutterAddress",
+  [DisputeKits.ArgentinaConsumerProtection]: "disputeKitGatedArgentinaConsumerProtectionAddress",
 } as const;
 
 /**

web/src/hooks/useVotingContext.tsx

@@ -9,6 +9,7 @@ import {
   useReadDisputeKitShutterIsVoteActive,
   useReadDisputeKitGatedIsVoteActive,
   useReadDisputeKitGatedShutterIsVoteActive,
+  useReadDisputeKitGatedArgentinaConsumerProtectionIsVoteActive,
 } from "hooks/contracts/generated";
 import { useDisputeDetailsQuery } from "hooks/queries/useDisputeDetailsQuery";
 import { useDrawQuery } from "hooks/queries/useDrawQuery";
@@ -81,6 +82,14 @@ export const VotingContextProvider: React.FC<{ children: React.ReactNode }> = ({
     args: hookArgs,
   });
 
+  const argentinaConsumerProtectionVoteResult = useReadDisputeKitGatedArgentinaConsumerProtectionIsVoteActive({
+    query: {
+      enabled: isEnabled && disputeKitName === DisputeKits.ArgentinaConsumerProtection,
+      refetchInterval: REFETCH_INTERVAL,
+    },
+    args: hookArgs,
+  });
+
   // Add a return for each DisputeKit
   const hasVoted = useMemo(() => {
     switch (disputeKitName) {
@@ -92,6 +101,8 @@ export const VotingContextProvider: React.FC<{ children: React.ReactNode }> = ({
         return gatedVoteResult.data;
       case DisputeKits.GatedShutter:
         return gatedShutterVoteResult.data;
+      case DisputeKits.ArgentinaConsumerProtection:
+        return argentinaConsumerProtectionVoteResult.data;
       default:
         return undefined;
     }
@@ -101,6 +112,7 @@ export const VotingContextProvider: React.FC<{ children: React.ReactNode }> = ({
     shutterVoteResult.data,
     gatedVoteResult.data,
     gatedShutterVoteResult.data,
+    argentinaConsumerProtectionVoteResult.data,
   ]);
 
   const wasDrawn = useMemo(() => !isUndefined(drawData) && drawData.draws.length > 0, [drawData]);

web/src/pages/Cases/CaseDetails/Appeal/Classic/Fund.tsx

@@ -7,12 +7,14 @@ import { useAccount, useBalance, usePublicClient } from "wagmi";
 
 import { Field, Button } from "@kleros/ui-components-library";
 
-import { REFETCH_INTERVAL } from "consts/index";
+import { REFETCH_INTERVAL, DisputeKits } from "consts/index";
 import {
   useSimulateDisputeKitClassicFundAppeal,
   useSimulateDisputeKitGatedFundAppeal,
+  useSimulateDisputeKitGatedArgentinaConsumerProtectionFundAppeal,
   useWriteDisputeKitClassicFundAppeal,
   useWriteDisputeKitGatedFundAppeal,
+  useWriteDisputeKitGatedArgentinaConsumerProtectionFundAppeal,
 } from "hooks/contracts/generated";
 import { useSelectedOptionContext, useFundingContext, useCountdownContext } from "hooks/useClassicAppealContext";
 import { useParsedAmount } from "hooks/useParsedAmount";
@@ -67,16 +69,23 @@ const useNeedFund = () => {
   return needFund;
 };
 
-const useFundAppeal = (parsedAmount: bigint, isGated: boolean, insufficientBalance?: boolean) => {
+const useFundAppeal = (
+  parsedAmount: bigint,
+  isGated: boolean,
+  disputeKitName?: DisputeKits,
+  insufficientBalance?: boolean
+) => {
   const { id } = useParams();
   const { selectedOption } = useSelectedOptionContext();
+  const isArgentinaCP = disputeKitName === DisputeKits.ArgentinaConsumerProtection;
+
   const {
     data: fundAppealConfig,
     isLoading,
     isError,
   } = useSimulateDisputeKitClassicFundAppeal({
     query: {
-      enabled: !isUndefined(id) && !isUndefined(selectedOption) && !insufficientBalance && !isGated,
+      enabled: !isUndefined(id) && !isUndefined(selectedOption) && !insufficientBalance && !isGated && !isArgentinaCP,
     },
     args: [BigInt(id ?? 0), BigInt(selectedOption?.id ?? 0)],
     value: parsedAmount,
@@ -89,31 +98,52 @@ const useFundAppeal = (parsedAmount: bigint, isGated: boolean, insufficientBalan
     isError: isErrorGated,
   } = useSimulateDisputeKitGatedFundAppeal({
     query: {
-      enabled: !isUndefined(id) && !isUndefined(selectedOption) && !insufficientBalance && isGated,
+      enabled: !isUndefined(id) && !isUndefined(selectedOption) && !insufficientBalance && isGated && !isArgentinaCP,
     },
     args: [BigInt(id ?? 0), BigInt(selectedOption?.id ?? 0)],
     value: parsedAmount,
   });
   const { writeContractAsync: fundAppealGated } = useWriteDisputeKitGatedFundAppeal();
 
-  return isGated
+  const {
+    data: fundAppealArgentinaCPConfig,
+    isLoading: isLoadingArgentinaCP,
+    isError: isErrorArgentinaCP,
+  } = useSimulateDisputeKitGatedArgentinaConsumerProtectionFundAppeal({
+    query: {
+      enabled: !isUndefined(id) && !isUndefined(selectedOption) && !insufficientBalance && isArgentinaCP,
+    },
+    args: [BigInt(id ?? 0), BigInt(selectedOption?.id ?? 0)],
+    value: parsedAmount,
+  });
+  const { writeContractAsync: fundAppealArgentinaCP } = useWriteDisputeKitGatedArgentinaConsumerProtectionFundAppeal();
+
+  return isArgentinaCP
     ? {
-        fundAppeal: fundAppealGated,
-        fundAppealConfig: fundAppealGatedConfig,
-        isLoading: isLoadingGated,
-        isError: isErrorGated,
+        data: fundAppealArgentinaCPConfig,
+        isLoading: isLoadingArgentinaCP,
+        isError: isErrorArgentinaCP,
+        fundAppeal: fundAppealArgentinaCP,
       }
-    : { fundAppeal, fundAppealConfig, isLoading, isError };
+    : isGated
+      ? {
+          fundAppeal: fundAppealGated,
+          fundAppealConfig: fundAppealGatedConfig,
+          isLoading: isLoadingGated,
+          isError: isErrorGated,
+        }
+      : { fundAppeal, fundAppealConfig, isLoading, isError };
 };
 
 interface IFund {
   amount: `${number}`;
   setAmount: (val: string) => void;
   setIsOpen: (val: boolean) => void;
   isGated: boolean;
+  disputeKitName?: DisputeKits;
 }
 
-const Fund: React.FC<IFund> = ({ amount, setAmount, setIsOpen, isGated }) => {
+const Fund: React.FC<IFund> = ({ amount, setAmount, setIsOpen, isGated, disputeKitName }) => {
   const needFund = useNeedFund();
   const { address, isDisconnected } = useAccount();
   const { data: balance } = useBalance({
@@ -137,6 +167,7 @@ const Fund: React.FC<IFund> = ({ amount, setAmount, setIsOpen, isGated }) => {
   const { fundAppealConfig, fundAppeal, isLoading, isError } = useFundAppeal(
     parsedAmount,
     isGated,
+    disputeKitName,
     insufficientBalance
   );
 

web/src/pages/Cases/CaseDetails/Appeal/Classic/index.tsx

@@ -2,6 +2,7 @@ import React, { useState } from "react";
 
 import AppealIcon from "svgs/icons/appeal.svg";
 
+import { DisputeKits } from "consts/index";
 import { useSelectedOptionContext } from "hooks/useClassicAppealContext";
 import { isUndefined } from "utils/index";
 
@@ -18,9 +19,10 @@ interface IClassic {
   isAppealMiniGuideOpen: boolean;
   toggleAppealMiniGuide: () => void;
   isGated: boolean;
+  disputeKitName?: DisputeKits;
 }
 
-const Classic: React.FC<IClassic> = ({ isAppealMiniGuideOpen, toggleAppealMiniGuide, isGated }) => {
+const Classic: React.FC<IClassic> = ({ isAppealMiniGuideOpen, toggleAppealMiniGuide, isGated, disputeKitName }) => {
   const [isPopupOpen, setIsPopupOpen] = useState(false);
   const [amount, setAmount] = useState("");
   const { selectedOption } = useSelectedOptionContext();
@@ -48,7 +50,12 @@ const Classic: React.FC<IClassic> = ({ isAppealMiniGuideOpen, toggleAppealMiniGu
       </AppealHeader>
       <label> The jury decision is appealed when two options are fully funded. </label>
       <Options setAmount={setAmount} />
-      <Fund amount={amount as `${number}`} setAmount={setAmount} setIsOpen={setIsPopupOpen} {...{ isGated }} />
+      <Fund
+        amount={amount as `${number}`}
+        setAmount={setAmount}
+        setIsOpen={setIsPopupOpen}
+        {...{ isGated, disputeKitName }}
+      />
     </>
   );
 };

web/src/pages/Cases/CaseDetails/Appeal/index.tsx

@@ -53,7 +53,10 @@ const Appeal: React.FC<{ currentPeriodIndex: number }> = ({ currentPeriodIndex }
   const { data: disputeData } = useDisputeDetailsQuery(id);
   const disputeKitAddress = disputeData?.dispute?.currentRound?.disputeKit?.address;
   const { disputeKitName } = useDisputeKitAddresses({ disputeKitAddress });
-  const isClassicDisputeKit = disputeKitName === DisputeKits.Classic || disputeKitName === DisputeKits.Gated;
+  const isClassicDisputeKit =
+    disputeKitName === DisputeKits.Classic ||
+    disputeKitName === DisputeKits.Gated ||
+    disputeKitName === DisputeKits.ArgentinaConsumerProtection;
   const isShutterDisputeKit = disputeKitName === DisputeKits.Shutter || disputeKitName === DisputeKits.GatedShutter;
   const isGated = Boolean(disputeKitName?.includes("Gated"));
   return (
@@ -64,7 +67,7 @@ const Appeal: React.FC<{ currentPeriodIndex: number }> = ({ currentPeriodIndex }
             <Classic
               isAppealMiniGuideOpen={isAppealMiniGuideOpen}
               toggleAppealMiniGuide={toggleAppealMiniGuide}
-              {...{ isGated }}
+              {...{ isGated, disputeKitName }}
             />
           )}
           {isShutterDisputeKit && (

web/src/pages/Cases/CaseDetails/Voting/Classic/Commit.tsx

@@ -6,7 +6,12 @@ import { useLocalStorage } from "react-use";
 import { keccak256, encodePacked } from "viem";
 import { useWalletClient, usePublicClient, useConfig } from "wagmi";
 
-import { simulateDisputeKitClassicCastCommit, simulateDisputeKitGatedCastCommit } from "hooks/contracts/generated";
+import { DisputeKits } from "consts/index";
+import {
+  simulateDisputeKitClassicCastCommit,
+  simulateDisputeKitGatedCastCommit,
+  simulateDisputeKitGatedArgentinaConsumerProtectionCastCommit,
+} from "hooks/contracts/generated";
 import useSigningAccount from "hooks/useSigningAccount";
 import { isUndefined } from "utils/index";
 import { wrapWithToast } from "utils/wrapWithToast";
@@ -26,9 +31,10 @@ interface ICommit {
   setIsOpen: (val: boolean) => void;
   refetch: () => void;
   isGated: boolean;
+  disputeKitName?: DisputeKits;
 }
 
-const Commit: React.FC<ICommit> = ({ arbitrable, voteIDs, setIsOpen, refetch, isGated }) => {
+const Commit: React.FC<ICommit> = ({ arbitrable, voteIDs, setIsOpen, refetch, isGated, disputeKitName }) => {
   const { id } = useParams();
   const parsedDisputeID = useMemo(() => BigInt(id ?? 0), [id]);
   const parsedVoteIDs = useMemo(() => voteIDs.map((voteID) => BigInt(voteID)), [voteIDs]);
@@ -60,7 +66,12 @@ const Commit: React.FC<ICommit> = ({ arbitrable, voteIDs, setIsOpen, refetch, is
       setSalt(JSON.stringify({ salt, choice: choice.toString() }));
       const commit = keccak256(encodePacked(["uint256", "uint256"], [BigInt(choice), BigInt(salt)]));
 
-      const simulate = isGated ? simulateDisputeKitGatedCastCommit : simulateDisputeKitClassicCastCommit;
+      const simulate =
+        disputeKitName === DisputeKits.ArgentinaConsumerProtection
+          ? simulateDisputeKitGatedArgentinaConsumerProtectionCastCommit
+          : isGated
+            ? simulateDisputeKitGatedCastCommit
+            : simulateDisputeKitClassicCastCommit;
 
       const { request } = await simulate(wagmiConfig, {
         args: [parsedDisputeID, parsedVoteIDs, commit],
@@ -85,6 +96,7 @@ const Commit: React.FC<ICommit> = ({ arbitrable, voteIDs, setIsOpen, refetch, is
       signingAccount,
       refetch,
       isGated,
+      disputeKitName,
     ]
   );