@berachain/berajs 0.1.1 → 0.1.2

package/src/hooks/governance/useIsCanceller.ts

@@ -0,0 +1,43 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { governanceTimelockAbi } from "~/abi/governance/governanceTimelock";
+import { CANCELLER_ROLE } from "~/actions/governance/constants";
+import { POLLING } from "~/enum/polling";
+import { assertPublicClient } from "~/errors/assert";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export const useIsCanceller = ({
+  account,
+  ...baseArgs
+}: {
+  account: Address | undefined;
+} & BeraJS.BaseFunctionArgs) => {
+  const publicClient = usePublicClient();
+  const { config: chainConfig } = parseBaseArgs(baseArgs);
+
+  const QUERY_KEY =
+    account && publicClient ? (["useCancellerRole", account] as const) : null;
+
+  return useSWR(
+    QUERY_KEY,
+    async ([, account]) => {
+      assertPublicClient(publicClient);
+
+      const canceller = await publicClient.readContract({
+        abi: governanceTimelockAbi,
+        address: chainConfig.governance.timelock,
+        functionName: "hasRole",
+        args: [CANCELLER_ROLE, account],
+      });
+
+      return canceller;
+    },
+    {
+      refreshInterval: POLLING.SLOW,
+      revalidateOnFocus: false,
+    },
+  );
+};

package/src/hooks/governance/usePollAllProposals.ts

@@ -0,0 +1,232 @@
+import { useEffect, useMemo, useState } from "react";
+import useSWRInfinite, { type SWRInfiniteResponse } from "swr/infinite";
+
+import {
+  type OrderDirection,
+  type Proposal_Filter,
+  Proposal_OrderBy,
+  type ProposalSelectionFragment,
+  ProposalStatus,
+} from "@berachain/graphql/governance";
+
+import { getAllProposals } from "~/actions/governance/getAllProposals";
+import { POLLING } from "~/enum/polling";
+import type { DefaultHookOptions } from "~/types";
+
+const DEFAULT_PER_PAGE = 10;
+
+const fromUiStatusToSubgraphStatuses = (
+  status: ProposalStatus,
+): ProposalStatus[] => {
+  switch (status) {
+    case ProposalStatus.QuorumNotReached:
+      return [ProposalStatus.Active, ProposalStatus.Pending];
+    case ProposalStatus.PendingQueue:
+    case ProposalStatus.Defeated:
+      return [ProposalStatus.Active];
+    case ProposalStatus.PendingExecution:
+      return [ProposalStatus.InQueue];
+    default:
+      return [status];
+  }
+};
+
+type UsePollAllProposalsArgs = {
+  topic: string;
+  where?: Proposal_Filter;
+  perPage?: number;
+  orderBy?: Proposal_OrderBy;
+  orderDirection?: OrderDirection;
+  status_in?: ProposalStatus[];
+  text?: string;
+  autoRefreshProposals?: boolean;
+};
+
+type ProposalResult = {
+  data: ProposalSelectionFragment[][];
+  hasMore: boolean;
+} & Omit<SWRInfiniteResponse<ProposalSelectionFragment[]>, "data">;
+
+type PollAllProposalsKey =
+  | [
+      "usePollAllProposals",
+      number,
+      string,
+      Proposal_Filter | undefined,
+      ProposalStatus[] | undefined,
+      Proposal_OrderBy | undefined,
+      OrderDirection | undefined,
+      number,
+      string | undefined,
+    ]
+  | null;
+
+export function usePollAllProposalsQueryKey(
+  topic: string,
+  args: Partial<UsePollAllProposalsArgs> = {},
+): (
+  pageIndex: number,
+  previousPageData?: ProposalSelectionFragment[],
+) => PollAllProposalsKey {
+  const subgraphPageSize = 2 * (args.perPage ?? DEFAULT_PER_PAGE);
+
+  return (pageIndex, previousPageData) => {
+    if (
+      pageIndex !== 0 &&
+      previousPageData &&
+      previousPageData.length < subgraphPageSize
+    ) {
+      return null;
+    }
+
+    const statuses = args.status_in
+      ?.flatMap(fromUiStatusToSubgraphStatuses)
+      .filter((s, i, arr) => arr.indexOf(s) === i);
+
+    return [
+      "usePollAllProposals",
+      pageIndex,
+      topic,
+      args.where,
+      statuses,
+      args.orderBy,
+      args.orderDirection,
+      subgraphPageSize,
+      args.text,
+    ];
+  };
+}
+
+/**
+ * Fetch all proposals for a given topic
+ */
+export function usePollAllProposals(
+  args: UsePollAllProposalsArgs,
+  options?: DefaultHookOptions & { autoRefresh?: boolean },
+): ProposalResult {
+  const autoRefreshProposals = options?.autoRefresh ?? false;
+
+  const perPage = args.perPage ?? DEFAULT_PER_PAGE;
+  const subgraphPageSize = 2 * perPage;
+
+  const getKey = usePollAllProposalsQueryKey(args.topic, args);
+
+  async function fetcher(key: PollAllProposalsKey) {
+    if (!key) return [];
+    const [
+      ,
+      pageIndex,
+      topic,
+      where,
+      statuses,
+      orderBy,
+      orderDirection,
+      pageSize,
+      text,
+    ] = key;
+
+    const proposals = await getAllProposals({
+      where: {
+        topics_contains: [topic],
+        status_in: statuses?.length ? statuses : undefined,
+        ...where,
+      },
+      orderBy,
+      orderDirection,
+      text,
+      perPage: pageSize,
+      offset: pageIndex * pageSize,
+    });
+
+    return (proposals ?? []).filter(Boolean) as ProposalSelectionFragment[];
+  }
+
+  const swr = useSWRInfinite<ProposalSelectionFragment[], PollAllProposalsKey>(
+    getKey,
+    fetcher,
+    {
+      // Increase initialSize in order to prefetch more proposals at a time.
+      initialSize: 1,
+      refreshInterval: options?.opts?.refreshInterval ?? POLLING.SLOW,
+      ...options?.opts,
+    },
+  );
+
+  const data = useMemo(() => {
+    if (!swr.data) return [];
+
+    const flattened = swr.data
+      .flat()
+      .filter((p) => {
+        if (!p) return false;
+        if (!args.status_in?.length) return true;
+        return args.status_in.includes(p.status);
+      })
+      .sort((a, b) => {
+        if (!args.text) return 0;
+        if (args.orderBy === Proposal_OrderBy.CreatedAt) {
+          const result = Number(b.createdAt) - Number(a.createdAt);
+          return args.orderDirection === "asc" ? result : -result;
+        }
+        return 0;
+      });
+
+    const chunked: ProposalSelectionFragment[][] = [];
+    for (let i = 0; i < flattened.length; i += perPage) {
+      chunked.push(flattened.slice(i, i + perPage));
+    }
+    return chunked;
+  }, [swr.data, args, perPage]);
+
+  const lastPage = swr.data?.[swr.data.length - 1];
+  const hasMore = !!lastPage && lastPage.length === subgraphPageSize;
+
+  const [timestamp, setTimestamp] = useState(Date.now() / 1000);
+
+  useEffect(() => {
+    if (!autoRefreshProposals) return;
+    const interval = setInterval(() => {
+      setTimestamp(Date.now() / 1000);
+    }, POLLING.FAST);
+
+    return () => clearInterval(interval);
+  }, [autoRefreshProposals]);
+
+  useEffect(() => {
+    if (!swr.data) return;
+
+    let shouldMutate = false;
+    for (const proposal of swr.data.flat()) {
+      switch (proposal.status) {
+        case ProposalStatus.Pending:
+          if (timestamp >= Number(proposal.voteStartAt)) {
+            shouldMutate = true;
+          }
+          break;
+        case ProposalStatus.Active:
+          if (timestamp >= Number(proposal.voteEndAt)) {
+            shouldMutate = true;
+          }
+          break;
+        case ProposalStatus.InQueue:
+          if (Date.now() / 1000 + 1 >= Number(proposal.queueEnd)) {
+            shouldMutate = true;
+          }
+          break;
+        default:
+          break;
+      }
+      if (shouldMutate) break;
+    }
+
+    if (shouldMutate) {
+      swr.mutate();
+    }
+  }, [swr.data, timestamp]);
+
+  return {
+    ...swr,
+    data,
+    hasMore,
+  };
+}

package/src/hooks/governance/usePollProposal.ts

@@ -0,0 +1,96 @@
+import { useEffect, useState } from "react";
+import useSWR from "swr";
+
+import {
+  ProposalStatus,
+  type ProposalWithVotesFragment,
+} from "@berachain/graphql/governance";
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getProposalDetails } from "~/actions/governance/getProposalDetails";
+import { POLLING } from "~/enum/polling";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+
+export interface UsePollProposalResponse
+  extends DefaultHookReturnType<ProposalWithVotesFragment> {}
+
+/**
+ * Polls a proposal and returns the proposal details.
+ * Pulls data from the subgraph and onchain.
+ *
+ * @param proposalId - The ID of the proposal to poll
+ * @param options - Optional configuration options
+ * @param options.autoRefresh - If true, the data will be refreshed automatically based on the block number and status threshold
+ * @returns {UsePollProposalResponse} Object containing:
+ *   - data: ProposalWithVotesFragment | undefined - The proposal data if successful
+ *   - error: Error | undefined - Error object if request failed
+ *   - isLoading: boolean - True while data is being fetched
+ *   - isValidating: boolean - True while data is being revalidated
+ *   - mutate: () => Promise<ProposalWithVotesFragment | undefined> - Function to manually refresh the data
+ *   - refresh: () => Promise<void> - Function to manually refresh the data
+ */
+export const usePollProposal = (
+  proposalId: string,
+  options?: DefaultHookOptions & { autoRefresh?: boolean },
+): UsePollProposalResponse => {
+  const autoRefreshProposal = options?.autoRefresh ?? false;
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY =
+    proposalId && publicClient
+      ? (["usePollProposal", proposalId] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    ([, proposalId]) => {
+      assertPublicClient(publicClient);
+
+      return getProposalDetails({ proposalId, client: publicClient });
+    },
+    {
+      ...options?.opts,
+      refreshInterval: options?.opts?.refreshInterval ?? POLLING.SLOW,
+    },
+  );
+
+  const [timestamp, setTimestamp] = useState(Date.now());
+
+  useEffect(() => {
+    if (!autoRefreshProposal) return;
+    const interval = setInterval(() => {
+      setTimestamp(Date.now() / 1000);
+    }, POLLING.FAST);
+
+    return () => clearInterval(interval);
+  }, []);
+
+  useEffect(() => {
+    if (swrResponse.data === undefined) return;
+
+    switch (swrResponse.data.status) {
+      case ProposalStatus.Pending:
+        if (timestamp >= Number(swrResponse.data.voteStartAt)) {
+          swrResponse.mutate();
+        }
+        break;
+      case ProposalStatus.Active:
+        if (timestamp >= Number(swrResponse.data.voteEndAt)) {
+          swrResponse.mutate();
+        }
+        break;
+      case ProposalStatus.InQueue:
+        if (Date.now() / 1000 + 1 >= Number(swrResponse.data.queueEnd)) {
+          swrResponse.mutate();
+        }
+        break;
+    }
+  }, [swrResponse.data?.status, timestamp]);
+
+  // const votes = swrResponse.data?.votes.nodes ?? [];
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.(),
+  };
+};

package/src/hooks/governance/usePollProposalThreshold.ts

@@ -0,0 +1,41 @@
+import useSWR from "swr";
+import { type Address, formatEther } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { governanceAbi } from "~/abi/governance/governance";
+import { POLLING } from "~/enum/polling";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookReturnType } from "~/types";
+
+export const usePollProposalThreshold = (
+  governorAddress: Address,
+): DefaultHookReturnType<{ votesThreshold: string }> => {
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY = publicClient
+    ? (["usePollProposalThreshold", governorAddress] as const)
+    : null;
+
+  const swrResponse = useSWR<{ votesThreshold: string }, any, typeof QUERY_KEY>(
+    QUERY_KEY,
+    async ([, governorAddress]) => {
+      assertPublicClient(publicClient);
+
+      const votesThreshold = await publicClient.readContract({
+        address: governorAddress,
+        abi: governanceAbi,
+        functionName: "proposalThreshold",
+      });
+      return { votesThreshold: formatEther(votesThreshold) };
+    },
+    {
+      refreshInterval: POLLING.SLOW,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: swrResponse.mutate,
+  };
+};

package/src/hooks/governance/usePollProposalVotes.ts

@@ -0,0 +1,64 @@
+import useSWRInfinite, { type SWRInfiniteKeyLoader } from "swr/infinite";
+
+import type { GetProposalVotesQueryVariables } from "@berachain/graphql/governance";
+
+import { getProposalVotes } from "~/actions/governance/getProposalVotes";
+
+type UsePollProposalVotesArgs = Omit<
+  GetProposalVotesQueryVariables,
+  "offset" | "limit"
+>;
+
+// const ACTUAL_PER_PAGE = 500;
+
+const DEFAULT_LIMIT = 1000;
+/**
+ * Fetches all the votes for a proposal from the Subgraph
+ * @param args - The arguments to pass to the query
+ * @param total - The total amount of pages of votes to fetch
+ */
+export const usePollProposalVotes = (
+  args: UsePollProposalVotesArgs,
+  total: number,
+) => {
+  return useSWRInfinite(
+    usePollProposalVotesQueryKey(args, total),
+    async ([_key, page]: [string, number]) => {
+      return getProposalVotes({
+        variables: {
+          ...args,
+          limit: DEFAULT_LIMIT,
+          offset: DEFAULT_LIMIT * page,
+        },
+      });
+    },
+    {
+      parallel: true,
+      // Fetches all the data at once, we limit the number of pages by providing a total
+      initialSize: Number.POSITIVE_INFINITY,
+    },
+  );
+};
+
+export const usePollProposalVotesQueryKey =
+  (
+    { ...args }: UsePollProposalVotesArgs,
+    total: number,
+  ): SWRInfiniteKeyLoader =>
+  (
+    pageIndex: number,
+    // previousPageData: Awaited<ReturnType<typeof getProposalVotes>>,
+  ) => {
+    if (pageIndex > Math.floor(total / DEFAULT_LIMIT)) {
+      return null;
+    }
+
+    return [
+      "usePollProposalVotes",
+      pageIndex,
+      DEFAULT_LIMIT,
+      args.proposalId,
+      args.orderBy,
+      args.orderDirection,
+    ];
+  };

package/src/hooks/governance/usePollUserDelegates.ts

@@ -0,0 +1,70 @@
+import useSWR from "swr";
+import { type Address, formatEther } from "viem";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { bgtAbi } from "~/abi/pol/bgt";
+import { POLLING } from "~/enum/polling";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export const usePollUserDelegates = (
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<{
+  delegate: Address;
+  currentVotes: string | undefined;
+}> => {
+  const { address: account } = useBeraWallet();
+  const publicClient = usePublicClient();
+  const QUERY_KEY = account
+    ? (["usePollUserDelegates", account] as const)
+    : null;
+
+  const swrResponse = useSWR<
+    { delegate: Address; currentVotes: string | undefined },
+    any,
+    typeof QUERY_KEY
+  >(
+    QUERY_KEY,
+    async ([, account]) => {
+      assertPublicClient(publicClient);
+      const { config } = parseBaseArgs({
+        chainId: publicClient.chain.id,
+      });
+      if (!publicClient || !account) {
+        throw new Error("usePollUserDelegates needs publicClient and account");
+      }
+
+      // use promise all to better catch errors and have type safety
+      const [delegate, currentVotes] = await Promise.all([
+        publicClient.readContract({
+          address: config.tokens.bgt,
+          abi: bgtAbi,
+          functionName: "delegates",
+          args: [account],
+        }),
+        publicClient.readContract({
+          address: config.tokens.bgt,
+          abi: bgtAbi,
+          functionName: "getVotes",
+          args: [account],
+        }),
+      ]);
+
+      return {
+        delegate: delegate,
+        currentVotes: formatEther(currentVotes),
+      };
+    },
+    {
+      ...options?.opts,
+      refreshInterval: options?.opts?.refreshInterval ?? POLLING.SLOW,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.(),
+  };
+};

package/src/hooks/governance/useProposalFromTx.ts

@@ -0,0 +1,37 @@
+import useSWR, { type SWRResponse } from "swr";
+import type { Address } from "viem";
+
+import type { ProposalWithVotesFragment } from "@berachain/graphql/governance";
+import { usePublicClient, useTransactionReceipt } from "@berachain/wagmi/hooks";
+
+import { getProposalFromTx } from "~/actions/governance/getProposalFromTx";
+
+export const useProposalFromTx = (
+  txHash?: Address,
+): SWRResponse<ProposalWithVotesFragment | null> => {
+  const { data: tx } = useTransactionReceipt({
+    hash: txHash,
+  });
+
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY =
+    tx && publicClient ? (["useProposalFromTx", txHash] as const) : null;
+
+  const swrResponse = useSWR(QUERY_KEY, async ([, txHash]) => {
+    if (!tx) {
+      throw new Error("Transaction not found");
+    }
+
+    // This might happen for some render order issues.
+    // Since tx is read by the external scope, it might be outdated.
+    // Throwing an error here will cause the hook to re-run with the latest tx object.
+    if (tx.transactionHash !== txHash) {
+      throw new Error("Transaction hash mismatch");
+    }
+
+    return getProposalFromTx({ tx, publicClient });
+  });
+
+  return swrResponse;
+};

package/src/hooks/governance/useProposalSnapshot.ts

@@ -0,0 +1,44 @@
+import type { SWRResponse } from "swr";
+import useSWRImmutable from "swr/immutable";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { governanceAbi } from "~/abi/governance/governance";
+import { assertPublicClient } from "~/errors/assert";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+/**
+ * Timepoint used to retrieve user’s votes and quorum. If using block
+ * number (as per Compound’s Comp), the snapshot is performed at
+ * the end of this block. Hence, voting for this proposal starts at the beginning of the following block.
+ *
+ * {@link https://docs.openzeppelin.com/contracts/5.x/api/governance#IGovernor-proposalSnapshot-uint256-}
+ */
+export const useProposalSnapshot = ({
+  proposalId,
+}: {
+  proposalId: number | bigint | string | undefined;
+}): SWRResponse<string> => {
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY =
+    publicClient && proposalId
+      ? (["useProposalSnapshot", proposalId] as const)
+      : null;
+
+  return useSWRImmutable(QUERY_KEY, async ([, proposalId]) => {
+    assertPublicClient(publicClient);
+
+    const { config } = parseBaseArgs({
+      chainId: publicClient.chain.id,
+    });
+    const snapshot = await publicClient.readContract({
+      abi: governanceAbi,
+      address: config.governance.governor,
+      functionName: "proposalSnapshot",
+      args: [BigInt(proposalId)],
+    });
+
+    return snapshot.toString();
+  });
+};

package/src/hooks/governance/useProposalState.ts

@@ -0,0 +1,48 @@
+import type { SWRResponse } from "swr";
+import useSWRImmutable from "swr/immutable";
+import type { Address } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { assertPublicClient } from "~/errors/assert";
+import { ProposalState } from "~/types";
+import { governanceAbi } from "../../abi/governance/governance";
+
+const ProposalStateMap: Record<ProposalState, string> = {
+  [ProposalState.Pending]: "pending",
+  [ProposalState.Active]: "active",
+  [ProposalState.Canceled]: "canceled",
+  [ProposalState.Defeated]: "defeated",
+  [ProposalState.Succeeded]: "succeeded",
+  [ProposalState.Queued]: "queued",
+  [ProposalState.Expired]: "expired",
+  [ProposalState.Executed]: "executed",
+};
+
+export const useProposalState = ({
+  proposalId,
+  governorAddress,
+}: {
+  proposalId: number | bigint | string | undefined;
+  governorAddress: Address;
+}): SWRResponse<string> => {
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY =
+    governorAddress && publicClient && proposalId
+      ? (["useProposalState", proposalId] as const)
+      : null;
+
+  return useSWRImmutable(QUERY_KEY, async ([, proposalId]) => {
+    assertPublicClient(publicClient);
+
+    const snapshot = (await publicClient.readContract({
+      abi: governanceAbi,
+      address: governorAddress,
+      functionName: "state",
+      args: [BigInt(proposalId)],
+    })) as ProposalState;
+
+    return ProposalStateMap[snapshot];
+  });
+};