feat(web): transaction-batcher

Author: tractorss

web/src/hooks/useTransactionBatcher.tsx

@@ -0,0 +1,76 @@
+import { encodeFunctionData, type SimulateContractParameters } from "viem";
+import { useAccount, useWriteContract } from "wagmi";
+import { createUseSimulateContract, createUseWriteContract } from "wagmi/codegen";
+
+import { DEFAULT_CHAIN } from "consts/chains";
+
+import { isUndefined } from "src/utils";
+
+const batcherAbi = [
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "targets",
+        type: "address[]",
+      },
+      {
+        internalType: "uint256[]",
+        name: "values",
+        type: "uint256[]",
+      },
+      {
+        internalType: "bytes[]",
+        name: "datas",
+        type: "bytes[]",
+      },
+    ],
+    name: "batchSend",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function",
+  },
+] as const;
+
+const useBatchSimulate = createUseSimulateContract({
+  abi: batcherAbi,
+  functionName: "batchSend",
+});
+
+export const useBatchWrite = createUseWriteContract({
+  abi: batcherAbi,
+  functionName: "batchSend",
+});
+
+const batcherAddress = {
+  421614: "0xe8061d185D865ce2B2FbCfDa628b5F147d8eB8Ab",
+};
+
+export type TransactionBatcherConfig = SimulateContractParameters[];
+
+const useTransactionBatcher = (configs?: TransactionBatcherConfig) => {
+  const { chainId } = useAccount();
+
+  const validConfigs = configs ?? [];
+  const {
+    data: batchConfig,
+    isLoading,
+    isError,
+  } = useBatchSimulate({
+    query: {
+      enabled: !isUndefined(configs),
+    },
+    address: batcherAddress[chainId ?? DEFAULT_CHAIN],
+    args: [
+      validConfigs.map((config) => config?.address),
+      validConfigs.map((config) => config?.value ?? BigInt(0)),
+      validConfigs.map((config) => encodeFunctionData(config)),
+    ],
+  });
+  const { writeContractAsync } = useWriteContract();
+
+  const executeBatch = () => batchConfig && writeContractAsync(batchConfig.request);
+  return { executeBatch, batchConfig, isError, isLoading };
+};
+
+export default useTransactionBatcher;

web/src/pages/Cases/CaseDetails/MaintenanceButtons/DistributeRewards.tsx

@@ -1,11 +1,13 @@
-import React, { useMemo, useState } from "react";
+import React, { useEffect, useMemo, useState } from "react";
 import styled from "styled-components";
 
-import { usePublicClient } from "wagmi";
+import { useAccount, usePublicClient } from "wagmi";
 
 import { Button } from "@kleros/ui-components-library";
 
-import { useSimulateKlerosCoreExecute, useWriteKlerosCoreExecute } from "hooks/contracts/generated";
+import { DEFAULT_CHAIN } from "consts/chains";
+import { klerosCoreAbi, klerosCoreAddress } from "hooks/contracts/generated";
+import useTransactionBatcher, { type TransactionBatcherConfig, useBatchWrite } from "hooks/useTransactionBatcher";
 import { wrapWithToast } from "utils/wrapWithToast";
 
 import { isUndefined } from "src/utils";
@@ -23,32 +25,48 @@ interface IDistributeRewards extends IBaseMaintenaceButton {
 
 const DistributeRewards: React.FC<IDistributeRewards> = ({ id, numberOfVotes, roundIndex, setIsOpen }) => {
   const [isSending, setIsSending] = useState(false);
+  const [contractConfigs, setContractConfigs] = useState<TransactionBatcherConfig>();
   const publicClient = usePublicClient();
+  const { chainId } = useAccount();
 
-  const {
-    data: executeConfig,
-    isLoading: isLoadingConfig,
-    isError,
-  } = useSimulateKlerosCoreExecute({
-    query: {
-      enabled: !isUndefined(id) && !isUndefined(numberOfVotes) && !isUndefined(roundIndex),
-    },
-    args: [BigInt(id ?? 0), BigInt(roundIndex ?? 0), BigInt(numberOfVotes ?? 0)],
-  });
+  useEffect(() => {
+    if (!id || !roundIndex || !numberOfVotes) return;
 
-  const { writeContractAsync: execute } = useWriteKlerosCoreExecute();
+    const baseArgs = {
+      abi: klerosCoreAbi,
+      address: klerosCoreAddress[chainId ?? DEFAULT_CHAIN],
+      functionName: "execute",
+    };
+
+    const argsArr: TransactionBatcherConfig = [];
+    let nbVotes = parseInt(numberOfVotes);
+
+    // each previous round has (n - 1)/2 jurors
+    for (let i = parseInt(roundIndex); i >= 0; i--) {
+      argsArr.push({ ...baseArgs, args: [BigInt(id), BigInt(i), BigInt(nbVotes)] });
+
+      nbVotes = (nbVotes - 1) / 2;
+    }
+
+    setContractConfigs(argsArr);
+  }, [id, roundIndex, numberOfVotes, chainId]);
+
+  const { batchConfig, isLoading: isLoadingConfig, isError } = useTransactionBatcher(contractConfigs);
+
+  const { writeContractAsync: executeBatch } = useBatchWrite();
 
   const isLoading = useMemo(() => isLoadingConfig || isSending, [isLoadingConfig, isSending]);
   const isDisabled = useMemo(
     () => isUndefined(id) || isUndefined(numberOfVotes) || isError || isLoading,
     [id, numberOfVotes, isError, isLoading]
   );
+
   const handleClick = () => {
-    if (!executeConfig) return;
+    if (!batchConfig) return;
 
     setIsSending(true);
 
-    wrapWithToast(async () => await execute(executeConfig.request), publicClient).finally(() => {
+    wrapWithToast(async () => await executeBatch(batchConfig.request), publicClient).finally(() => {
       setIsOpen(false);
     });
   };