fix: coderabbit and other type fixes

Author: jaybuidl

kleros-sdk/src/dataMappings/actions/fetchIpfsJsonAction.ts

@@ -12,15 +12,22 @@ export const fetchIpfsJsonAction = async (mapping: FetchIpfsJsonMapping) => {
     httpUri = ipfsUri.replace("ipfs://", "https://ipfs.io/ipfs/");
   } else if (!ipfsUri.startsWith("http")) {
     httpUri = `https://ipfs.io/ipfs/${ipfsUri}`;
+  } else {
+    throw new Error("Invalid IPFS URI format");
   }
+
   const response = await fetch(httpUri, { method: "GET" });
 
-  if (response.headers.get("content-length") > MAX_BYTE_SIZE) {
+  if (!response) {
+    throw new Error("Failed to fetch data from IPFS");
+  }
+
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && parseInt(contentLength) > MAX_BYTE_SIZE) {
     throw new Error("Response size is too large");
   }
 
   const contentType = response.headers.get("content-type");
-
   if (!contentType || !contentType.includes("application/json")) {
     throw new Error("Fetched data is not JSON");
   }

kleros-sdk/src/dataMappings/executeActions.ts

@@ -14,8 +14,16 @@ import {
 } from "./utils/actionTypeValidators";
 import { ActionMapping } from "./utils/actionTypes";
 import { replacePlaceholdersWithValues } from "./utils/replacePlaceholdersWithValues";
+import { Address } from "viem";
 
-export const executeAction = async (mapping: ActionMapping, context: Record<string, unknown> = {}) => {
+// Add these type definitions at the top of the file
+type ActionResult = Record<string, unknown> | null | undefined;
+
+// Update the function signature
+export const executeAction = async (
+  mapping: ActionMapping,
+  context: Record<string, unknown> = {}
+): Promise<ActionResult> => {
   mapping = replacePlaceholdersWithValues(mapping, context);
 
   switch (mapping.type) {
@@ -24,21 +32,24 @@ export const executeAction = async (mapping: ActionMapping, context: Record<stri
     case "json":
       return jsonAction(validateJsonMapping(mapping));
     case "abi/call":
-      return await callAction(validateAbiCallMapping(mapping), context.alchemyApiKey);
+      return await callAction(validateAbiCallMapping(mapping), context.alchemyApiKey as string);
     case "abi/event":
-      return await eventAction(validateAbiEventMapping(mapping), context.alchemyApiKey);
+      return await eventAction(validateAbiEventMapping(mapping), context.alchemyApiKey as string);
     case "fetch/ipfs/json":
       return await fetchIpfsJsonAction(validateFetchIpfsJsonMapping(mapping));
     case "reality":
       mapping = validateRealityMapping(mapping);
-      return await retrieveRealityData(mapping.realityQuestionID, context.arbitrableAddress);
+      return await retrieveRealityData(mapping.realityQuestionID, context.arbitrableAddress as Address);
     default:
       throw new Error(`Unsupported action type: ${mapping.type}`);
   }
 };
 
-export const executeActions = async (mappings, initialContext = {}) => {
-  const context = { ...initialContext };
+export const executeActions = async (
+  mappings: ActionMapping[],
+  initialContext: Record<string, unknown> = {}
+): Promise<Record<string, unknown>> => {
+  const context: Record<string, unknown> = { ...initialContext };
 
   for (const mapping of mappings) {
     const actionResult = await executeAction(mapping, context);

kleros-sdk/src/dataMappings/retrieveRealityData.ts

@@ -59,6 +59,10 @@ export const retrieveRealityData = async (realityQuestionID: string, arbitrable?
   const templateData = await executeAction(templateMapping);
   console.log("templateData", templateData);
 
+  if (!templateData || !questionData) {
+    throw new Error("Failed to retrieve template or question data");
+  }
+
   const rc_question = require("@reality.eth/reality-eth-lib/formatters/question.js");
   const populatedTemplate = rc_question.populatedJSONForTemplate(
     templateData.questionText,
@@ -67,7 +71,15 @@ export const retrieveRealityData = async (realityQuestionID: string, arbitrable?
 
   console.log("populatedTemplate", populatedTemplate);
 
-  let answers = [];
+  interface RealityAnswer {
+    title: string;
+    description: string;
+    id: string;
+    reserved: boolean;
+    last?: boolean;
+  }
+
+  let answers: RealityAnswer[] = [];
   if (populatedTemplate.type === "bool") {
     answers = [
       {

kleros-sdk/src/dataMappings/utils/createResultObject.ts

@@ -1,5 +1,9 @@
-export const createResultObject = (sourceData, seek: string[], populate: string[]) => {
-  const result = {};
+export const createResultObject = (
+  sourceData: Record<string, any>,
+  seek: string[],
+  populate: string[]
+): Record<string, any> => {
+  const result: Record<string, any> = {};
 
   const getNestedValue = (obj: any, path: string) => {
     return path.split(".").reduce((acc, part) => {

web-devtools/next.config.mjs

@@ -8,7 +8,7 @@ const nextConfig = {
     // Dangerously allow production builds to successfully complete even if
     // your project has type errors.
     // !! WARN !!
-    ignoreBuildErrors: true,
+    ignoreBuildErrors: process.env.NODE_ENV === 'development',
   },
   webpack(config) {
     // Grab the existing rule that handles SVG imports

web-devtools/src/app/(main)/dispute-template/FetchDisputeRequestInput.tsx

@@ -74,6 +74,7 @@ const FetchDisputeRequestInput: React.FC<IFetchDisputeRequestInput> = ({ setPara
   const [txnHash, setTxnHash] = useState<string>("");
   const [debouncedTxnHash, setDebouncedTxnHash] = useState<string>("");
   const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
 
   useDebounce(
     () => {
@@ -89,14 +90,16 @@ const FetchDisputeRequestInput: React.FC<IFetchDisputeRequestInput> = ({ setPara
       try {
         const params = await getDisputeRequestParamsFromTxn(debouncedTxnHash as `0x${string}`, chainId);
         if (!isUndefined(params)) setParams(params);
+        setError(null);
       } catch (error) {
         console.error("Error fetching dispute request params:", error);
+        setError("Failed to fetch dispute request parameters");
       } finally {
         setLoading(false);
       }
     };
     if (debouncedTxnHash && chainId) fetchData();
-  }, [debouncedTxnHash]);
+  }, [debouncedTxnHash, chainId]);
 
   return (
     <Container>
@@ -106,7 +109,7 @@ const FetchDisputeRequestInput: React.FC<IFetchDisputeRequestInput> = ({ setPara
           value={txnHash}
           placeholder="Enter transaction hash"
           onChange={(e) => setTxnHash(e.target.value)}
-          message={loading ? "fetching ..." : ""}
+          message={loading ? "fetching ..." : error || ""}
         />
         <StyledChainInput
           value={chainId}

web-devtools/src/app/(main)/ruler/ManualRuling.tsx

@@ -117,7 +117,7 @@ const ManualRuling: React.FC = () => {
         <LabeledInput label="Ruling" type="number" value={ruling} onChange={(e) => setRuling(Number(e.target.value))} />
         <LabeledInput label="Tie" inputType="checkbox" checked={tie} onChange={() => setTie((prev) => !prev)} />
         <LabeledInput
-          label="Overidden"
+          label="Overridden"
           inputType="checkbox"
           checked={overridden}
           onChange={() => setOverridden((prev) => !prev)}

web-devtools/src/app/(main)/ruler/RulingModes.tsx

@@ -262,7 +262,7 @@ const RulingModes: React.FC = () => {
               disabled={rulingMode !== RULING_MODE.AutomaticPreset}
             />
             <LabeledInput
-              label="Overidden"
+              label="Overridden"
               inputType="checkbox"
               checked={overridden}
               onChange={() => setOverridden((prev) => !prev)}

web-devtools/src/app/(main)/ruler/SelectArbitrable.tsx

@@ -1,7 +1,8 @@
 import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import styled, { css } from "styled-components";
 
-import { Address } from "viem";
+import { Address, PublicClient } from "viem";
+import { usePublicClient } from "wagmi";
 
 import { Copiable, DropdownSelect, Field } from "@kleros/ui-components-library";
 
@@ -10,6 +11,7 @@ import { shortenAddress } from "utils/shortenAddress";
 import { klerosCoreAddress } from "hooks/contracts/generated";
 import { DEFAULT_CHAIN } from "consts/chains";
 import { landscapeStyle } from "styles/landscapeStyle";
+import { validateAddress } from "utils/validateAddressOrEns";
 
 const Container = styled.div`
   width: 100%;
@@ -78,10 +80,19 @@ const StyledDropdown = styled(DropdownSelect)`
   }
 `;
 
+const ErrorMessage = styled.div`
+  color: red;
+  font-size: 14px;
+  margin-top: 4px;
+`;
+
 const SelectArbitrable: React.FC = () => {
   const { arbitrable, setArbitrable, knownArbitrables } = useRulerContext();
+  const publicClient = usePublicClient({ chainId: 1 }) as PublicClient;
   const ref = useRef<HTMLDivElement>(null);
   const [isClient, setIsClient] = useState(false);
+  const [inputValue, setInputValue] = useState("");
+  const [error, setError] = useState<string | null>(null);
 
   // hydration workaround, local storage is inevitably going to be different, so knownArbitrables will be different
   // server and client side
@@ -102,6 +113,25 @@ const SelectArbitrable: React.FC = () => {
     child.click();
   }, [knownArbitrables, ref]);
 
+  const handleInputChange = useCallback(
+    async (value: string) => {
+      setInputValue(value);
+      setError(null);
+
+      if (value) {
+        const isValid = await validateAddress(value, publicClient);
+        if (isValid) {
+          setArbitrable(value as Address);
+        } else {
+          setError("Invalid address or ENS name");
+        }
+      } else {
+        setArbitrable("" as Address);
+      }
+    },
+    [publicClient, setArbitrable]
+  );
+
   return (
     <Container>
       <AddressContainer>
@@ -113,15 +143,18 @@ const SelectArbitrable: React.FC = () => {
       <Arbitrables suppressHydrationWarning={true}>
         <StyledLabel>Arbitrable:</StyledLabel>
         <SelectContainer ref={ref}>
-          <StyledDropdown defaultValue={arbitrable} items={items} callback={(val) => setArbitrable(val as Address)} />
+          <StyledDropdown
+            defaultValue={arbitrable}
+            items={items}
+            callback={(val) => handleInputChange(val.toString())}
+          />
           <StyledField
-            value={arbitrable}
+            value={inputValue}
             placeholder="Enter Arbitrable"
-            onChange={(e) => {
-              setArbitrable(e.target.value as Address);
-            }}
+            onChange={(e) => handleInputChange(e.target.value)}
             onClick={openDropdown}
           />
+          {error && <ErrorMessage>{error}</ErrorMessage>}
         </SelectContainer>
       </Arbitrables>
     </Container>

web-devtools/wagmi.config.ts

@@ -1,27 +1,16 @@
 import { readdir, readFile } from "fs/promises";
 import { parse, join } from "path";
 
-import { Chain } from "@wagmi/chains";
 import { type Config, type ContractConfig, defineConfig } from "@wagmi/cli";
 import { react, actions } from "@wagmi/cli/plugins";
 import dotenv from "dotenv";
-import { type Abi } from "viem";
-
-import IArbitrableV2 from "@kleros/kleros-v2-contracts/artifacts/src/arbitration/interfaces/IArbitrableV2.sol/IArbitrableV2.json" assert { type: "json" };
-import IHomeGateway from "@kleros/kleros-v2-contracts/artifacts/src/gateway/interfaces/IHomeGateway.sol/IHomeGateway.json" assert { type: "json" };
+import { Chain } from "viem";
 
 import { ArbitratorTypes, getArbitratorType } from "./src/consts/arbitratorTypes";
+import { arbitrum, arbitrumSepolia, gnosis, gnosisChiado, mainnet, sepolia } from "viem/chains";
 
 dotenv.config();
 
-type ArtifactPartial = {
-  abi: Abi;
-};
-
-const getAbi = (artifact: any) => {
-  return (artifact as ArtifactPartial).abi;
-};
-
 const readArtifacts = async (type: ArbitratorTypes, viemChainName: string, hardhatChainName?: string) => {
   const artifactSuffix =
     type === ArbitratorTypes.vanilla
@@ -30,8 +19,16 @@ const readArtifacts = async (type: ArbitratorTypes, viemChainName: string, hardh
   const vanillaArtifacts = ["KlerosCore", "DisputeKitClassic", "SortitionModule", "DisputeResolver", "KlerosCoreRuler"];
   const typeSpecificArtifacts = vanillaArtifacts.map((artifact) => `${artifact}${artifactSuffix}`);
 
-  const chains = await import("wagmi/chains");
-  const chain = (chains as any)[viemChainName] as Chain;
+  const chainMap: Record<string, Chain> = {
+    arbitrum,
+    arbitrumSepolia,
+    sepolia,
+    mainnet,
+    gnosisChiado,
+    gnosis,
+  };
+
+  const chain = chainMap[viemChainName];
   if (!chain) {
     throw new Error(`Viem chain ${viemChainName} not found`);
   }
@@ -98,17 +95,7 @@ const getConfig = async (): Promise<Config> => {
 
   return {
     out: "src/hooks/contracts/generated.ts",
-    contracts: [
-      ...deploymentContracts,
-      {
-        name: "IHomeGateway",
-        abi: getAbi(IHomeGateway),
-      },
-      {
-        name: "IArbitrableV2",
-        abi: getAbi(IArbitrableV2),
-      },
-    ],
+    contracts: [...deploymentContracts],
     plugins: [react(), actions()],
   };
 };