@berachain/berajs 0.2.8-beta.8 → 0.2.9

package/dist/hooks/governance/exports.mjs

@@ -0,0 +1,888 @@
+import {
+  checkProposalField,
+  getAllProposals,
+  getBodyErrors,
+  getProposalDetails,
+  getProposalFromTx,
+  getProposalVotes
+} from "../../chunk-AFN4CVD3.mjs";
+import "../../chunk-DKMAIU74.mjs";
+import "../../chunk-SGIJVHZO.mjs";
+import {
+  assertPublicClient
+} from "../../chunk-KQUMKB66.mjs";
+import {
+  parseBaseArgs
+} from "../../chunk-75M6TF7M.mjs";
+import "../../chunk-J5I45WGQ.mjs";
+
+// src/hooks/governance/useCreateProposal.ts
+import { useCallback, useEffect, useState } from "react";
+
+// src/actions/governance/getProposalParams.ts
+import matter from "gray-matter";
+import {
+  encodeFunctionData,
+  erc20Abi,
+  parseAbiItem,
+  toHex
+} from "viem";
+import { beraChefAbi } from "@berachain/abis/pol/rewards/beraChef";
+import { rewardVaultAbi } from "@berachain/abis/pol/rewards/rewardVault";
+
+// src/utils/hasAnyTruthyValues.ts
+function hasAnyTruthyValues(obj) {
+  return Object.values(obj).some((value) => {
+    if (Array.isArray(value)) {
+      return value.some(
+        (item) => typeof item === "object" && item !== null ? hasAnyTruthyValues(item) : !!item
+      );
+    }
+    if (typeof value === "object" && value !== null) {
+      return hasAnyTruthyValues(value);
+    }
+    return !!value;
+  });
+}
+
+// src/actions/governance/getProposalParams.ts
+function getProposalParams({
+  proposal,
+  currentTopic,
+  onError
+}) {
+  const e = getBodyErrors({ proposal, currentTopic });
+  const actions = [];
+  e.actions = proposal.actions.map((action, idx) => {
+    const errors = {};
+    errors.target = checkProposalField({
+      fieldOrType: "address",
+      value: action.target
+    });
+    if (action.type === "custom-action" /* CUSTOM_PROPOSAL */) {
+      if (action.input === "ABI") {
+        errors.ABI = checkProposalField({
+          fieldOrType: "abi",
+          value: action.ABI
+        });
+        if (!action.functionSignature) {
+          errors.functionSignature = "Required" /* REQUIRED */;
+        } else {
+          try {
+            const parsedSignatureAbi = parseAbiItem(action.functionSignature);
+            if (parsedSignatureAbi.type !== "function") {
+              console.error(
+                "parsedSignatureAbi is not a function",
+                parsedSignatureAbi
+              );
+              errors.functionSignature = "Invalid ABI" /* INVALID_ABI */;
+            } else {
+              errors.args = parsedSignatureAbi.inputs.map((input, index) => {
+                try {
+                  if ("components" in input) {
+                    return checkProposalField({
+                      // @ts-expect-error this is not typed, will throw if not valid
+                      fieldOrType: input.type,
+                      value: action.args?.[index],
+                      components: input.components
+                    });
+                  }
+                  return checkProposalField({
+                    // @ts-expect-error this is not typed, will throw if not valid
+                    fieldOrType: input.type,
+                    value: action.args?.[index]
+                  });
+                } catch {
+                  return null;
+                }
+              });
+              if (!errors.args.some((v) => v)) {
+                actions[idx] = encodeFunctionData({
+                  abi: [parsedSignatureAbi],
+                  args: action.args
+                });
+              }
+            }
+          } catch {
+            errors.functionSignature = "Invalid ABI" /* INVALID_ABI */;
+          }
+        }
+      } else if (action.input === "rawCalldata") {
+        errors.rawCalldata = checkProposalField({
+          fieldOrType: "hex",
+          value: action.rawCalldata
+        });
+        actions[idx] = action.rawCalldata;
+      } else if (action.input === "message") {
+        errors.message = checkProposalField({
+          fieldOrType: "string",
+          value: action.message
+        });
+        actions[idx] = toHex(action.message);
+      } else {
+        throw new Error("Invalid input type");
+      }
+    } else if (action.type === "whitelist-reward-vault" /* WHITELIST_REWARD_VAULT */ || action.type === "blacklist-reward-vault" /* BLACKLIST_REWARD_VAULT */) {
+      errors.vault = checkProposalField({
+        fieldOrType: "address",
+        value: action.vault
+      });
+      if (!errors.vault) {
+        const whiteList = action.type === "whitelist-reward-vault" /* WHITELIST_REWARD_VAULT */;
+        actions[idx] = encodeFunctionData({
+          abi: beraChefAbi,
+          functionName: "setVaultWhitelistedStatus",
+          args: [action.vault, whiteList, ""]
+        });
+      }
+    } else if (action.type === "whitelist-reward-vault-incentive" /* WHITELIST_REWARD_VAULT_INCENTIVE */) {
+      errors.token = checkProposalField({
+        fieldOrType: "address",
+        value: action.token
+      });
+      errors.minIncentiveRate = checkProposalField({
+        fieldOrType: "uint256",
+        value: action.minIncentiveRate
+      });
+      errors.managerAddress = checkProposalField({
+        fieldOrType: "address",
+        value: action.managerAddress
+      });
+      if (!errors.token && !errors.minIncentiveRate && !errors.managerAddress) {
+        actions[idx] = encodeFunctionData({
+          abi: rewardVaultAbi,
+          functionName: "whitelistIncentiveToken",
+          args: [
+            action.token,
+            BigInt(action.minIncentiveRate),
+            action.managerAddress
+          ]
+        });
+      }
+    } else if (action.type === "erc20-transfer" /* ERC20_TRANSFER */) {
+      errors.amount = checkProposalField({
+        fieldOrType: "uint256",
+        value: action.amount
+      });
+      errors.to = checkProposalField({
+        fieldOrType: "address",
+        value: action.to
+      });
+      if (!errors.amount && !errors.to) {
+        actions[idx] = encodeFunctionData({
+          abi: erc20Abi,
+          functionName: "transfer",
+          args: [action.to, BigInt(action.amount)]
+        });
+      }
+    }
+    const hasErrors = hasAnyTruthyValues(errors);
+    if (!hasErrors) {
+      return null;
+    }
+    return errors;
+  });
+  onError?.(e);
+  if (Object.getOwnPropertyNames(e).map((name) => e[name]).some((v) => {
+    if (Array.isArray(v)) {
+      return v.filter((v2) => v2).length > 0;
+    }
+    if (v === null) {
+      return false;
+    }
+    return !!v;
+  })) {
+    console.warn("Proposal has errors", e);
+    return;
+  }
+  if (actions.length === 0) {
+    throw new Error("No actions submitted in proposal");
+  }
+  const link = new URL(proposal.forumLink);
+  const description = matter.stringify(proposal.description, {
+    title: proposal.title,
+    topics: Array.from(proposal.topic.values()),
+    forumLink: link.toString(),
+    version: "1.0.0",
+    "content-encoding": "utf-8",
+    "content-type": "text/markdown",
+    actions: proposal.actions.map((action) => {
+      const actionMetadata = {
+        type: action.type
+      };
+      if (action.type === "custom-action" /* CUSTOM_PROPOSAL */) {
+        actionMetadata.inputType = action.input;
+      }
+      return actionMetadata;
+    })
+  });
+  return [
+    proposal.actions.map((action) => action.target),
+    proposal.actions.map((action) => action.value ?? 0n),
+    actions,
+    description
+  ];
+}
+
+// src/hooks/governance/useCreateProposal.ts
+var defaultAction = {
+  type: "custom-action" /* CUSTOM_PROPOSAL */,
+  target: "",
+  ABI: "",
+  value: 0n,
+  functionSignature: "",
+  args: [],
+  input: "ABI",
+  rawCalldata: "0x",
+  message: ""
+};
+var useCreateProposal = ({
+  initialData = {},
+  currentTopic,
+  onError
+}) => {
+  const [proposal, setProposal] = useState({
+    title: "",
+    description: "",
+    forumLink: "",
+    actions: [defaultAction],
+    ...initialData,
+    topic: /* @__PURE__ */ new Set()
+  });
+  useEffect(() => {
+    setProposal((p) => ({
+      ...p,
+      topic: /* @__PURE__ */ new Set([currentTopic.id])
+    }));
+  }, [currentTopic]);
+  const addProposalAction = useCallback(() => {
+    setProposal((p) => ({ ...p, actions: [...p.actions, defaultAction] }));
+  }, []);
+  const removeProposalAction = useCallback(
+    (idx) => {
+      setProposal((p) => {
+        const actions = [...p.actions];
+        actions.splice(idx, 1);
+        return { ...p, actions };
+      });
+    },
+    [setProposal]
+  );
+  const computeParamsAndErrors = useCallback(() => {
+    if (!proposal) {
+      return;
+    }
+    const computedParams = getProposalParams({
+      proposal,
+      currentTopic,
+      onError
+    });
+    return computedParams;
+  }, [proposal, currentTopic]);
+  return {
+    proposal,
+    setProposal,
+    addProposalAction,
+    removeProposalAction,
+    computeParamsAndErrors
+  };
+};
+
+// src/hooks/governance/useGetPastVotes.ts
+import useSWRImmutable2 from "swr/immutable";
+import { formatUnits } from "viem";
+import { bgtAbi } from "@berachain/abis/pol/bgt";
+import { useBeraWallet, usePublicClient as usePublicClient2 } from "@berachain/wagmi/hooks";
+
+// src/hooks/governance/useProposalSnapshot.ts
+import useSWRImmutable from "swr/immutable";
+import { berachainGovernanceAbi as governanceAbi } from "@berachain/abis/gov/berachainGovernance";
+import { usePublicClient } from "@berachain/wagmi/hooks";
+var useProposalSnapshot = ({
+  proposalId
+}) => {
+  const publicClient = usePublicClient();
+  const QUERY_KEY = publicClient && proposalId ? ["useProposalSnapshot", proposalId] : null;
+  return useSWRImmutable(QUERY_KEY, async ([, proposalId2]) => {
+    assertPublicClient(publicClient);
+    const { config } = parseBaseArgs({
+      chainId: publicClient.chain.id
+    });
+    const snapshot = await publicClient.readContract({
+      abi: governanceAbi,
+      address: config.governance.governor,
+      functionName: "proposalSnapshot",
+      args: [BigInt(proposalId2)]
+    });
+    return snapshot.toString();
+  });
+};
+
+// src/hooks/governance/useGetPastVotes.ts
+var useGetPastVotes = (args) => {
+  const { address: account } = useBeraWallet();
+  const publicClient = usePublicClient2();
+  const wallet = args.wallet || account;
+  const { data: snapshot } = useProposalSnapshot({
+    proposalId: args.proposalId
+  });
+  const ts = args.timepoint || snapshot;
+  const QUERY_KEY = ts && publicClient && wallet ? ["useGetPastVotes", ts, wallet] : null;
+  return useSWRImmutable2(QUERY_KEY, async ([, ts2, wallet2]) => {
+    assertPublicClient(publicClient);
+    const { config } = parseBaseArgs({
+      chainId: publicClient.chain.id
+    });
+    if (Number(ts2) > Date.now() / 1e3) {
+      throw new Error("timepoint is in the future");
+    }
+    const votes = await publicClient.readContract({
+      abi: bgtAbi,
+      address: config.tokens.bgt,
+      functionName: "getPastVotes",
+      args: [wallet2, BigInt(ts2)]
+    });
+    return formatUnits(votes, 18);
+  });
+};
+
+// src/hooks/governance/useHasVoted.ts
+import useSWR from "swr";
+import { isAddress } from "viem";
+import { berachainGovernanceAbi as governanceAbi2 } from "@berachain/abis/gov/berachainGovernance";
+import { useBeraWallet as useBeraWallet2, usePublicClient as usePublicClient3 } from "@berachain/wagmi/hooks";
+var useHasVoted = ({
+  proposalId,
+  wallet
+}) => {
+  const { address: account } = useBeraWallet2();
+  const publicClient = usePublicClient3();
+  const address = wallet || account;
+  return useSWR(
+    publicClient && address && isAddress(address) ? ["useHasVoted", proposalId, address] : null,
+    ([, proposalId2, address2]) => {
+      assertPublicClient(publicClient);
+      const { config } = parseBaseArgs({
+        chainId: publicClient.chain.id
+      });
+      return publicClient.readContract({
+        address: config.governance.governor,
+        abi: governanceAbi2,
+        functionName: "hasVoted",
+        args: [BigInt(proposalId2), address2]
+      });
+    }
+  );
+};
+
+// src/hooks/governance/useIsCanceller.ts
+import useSWR2 from "swr";
+import { timeLockAbi as governanceTimelockAbi } from "@berachain/abis/gov/timeLock";
+import { usePublicClient as usePublicClient4 } from "@berachain/wagmi/hooks";
+
+// src/actions/governance/constants.ts
+var CANCELLER_ROLE = "0xfd643c72710c63c0180259aba6b2d05451e3591a24e58b62239378085726f783";
+
+// src/hooks/governance/useIsCanceller.ts
+var useIsCanceller = ({
+  account,
+  ...baseArgs
+}) => {
+  const publicClient = usePublicClient4();
+  const { config: chainConfig } = parseBaseArgs(baseArgs);
+  const QUERY_KEY = account && publicClient ? ["useCancellerRole", account] : null;
+  return useSWR2(
+    QUERY_KEY,
+    async ([, account2]) => {
+      assertPublicClient(publicClient);
+      const canceller = await publicClient.readContract({
+        abi: governanceTimelockAbi,
+        address: chainConfig.governance.timelock,
+        functionName: "hasRole",
+        args: [CANCELLER_ROLE, account2]
+      });
+      return canceller;
+    },
+    {
+      refreshInterval: 18e4 /* SLOW */,
+      revalidateOnFocus: false
+    }
+  );
+};
+
+// src/hooks/governance/usePollAllProposals.ts
+import { useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+import useSWRInfinite from "swr/infinite";
+import {
+  Proposal_OrderBy,
+  ProposalStatus
+} from "@berachain/graphql/governance";
+var DEFAULT_PER_PAGE = 10;
+var fromUiStatusToSubgraphStatuses = (status) => {
+  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];
+  }
+};
+function usePollAllProposalsQueryKey(topic, args = {}) {
+  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
+    ];
+  };
+}
+function usePollAllProposals(args, options) {
+  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) {
+    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 : void 0,
+        ...where
+      },
+      orderBy,
+      orderDirection,
+      text,
+      perPage: pageSize,
+      offset: pageIndex * pageSize
+    });
+    return (proposals ?? []).filter(Boolean);
+  }
+  const swr = useSWRInfinite(
+    getKey,
+    fetcher,
+    {
+      // Increase initialSize in order to prefetch more proposals at a time.
+      initialSize: 1,
+      refreshInterval: options?.opts?.refreshInterval ?? 18e4 /* 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 = [];
+    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] = useState2(Date.now() / 1e3);
+  useEffect2(() => {
+    if (!autoRefreshProposals) return;
+    const interval = setInterval(() => {
+      setTimestamp(Date.now() / 1e3);
+    }, 1e4 /* FAST */);
+    return () => clearInterval(interval);
+  }, [autoRefreshProposals]);
+  useEffect2(() => {
+    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() / 1e3 + 1 >= Number(proposal.queueEnd)) {
+            shouldMutate = true;
+          }
+          break;
+        default:
+          break;
+      }
+      if (shouldMutate) break;
+    }
+    if (shouldMutate) {
+      swr.mutate();
+    }
+  }, [swr.data, timestamp]);
+  return {
+    ...swr,
+    data,
+    hasMore
+  };
+}
+
+// src/hooks/governance/usePollProposal.ts
+import { useEffect as useEffect3, useState as useState3 } from "react";
+import useSWR3 from "swr";
+import {
+  ProposalStatus as ProposalStatus2
+} from "@berachain/graphql/governance";
+import { usePublicClient as usePublicClient5 } from "@berachain/wagmi/hooks";
+var usePollProposal = (proposalId, options) => {
+  const autoRefreshProposal = options?.autoRefresh ?? false;
+  const publicClient = usePublicClient5();
+  const QUERY_KEY = proposalId && publicClient ? ["usePollProposal", proposalId] : null;
+  const swrResponse = useSWR3(
+    QUERY_KEY,
+    ([, proposalId2]) => {
+      assertPublicClient(publicClient);
+      return getProposalDetails({ proposalId: proposalId2, client: publicClient });
+    },
+    {
+      ...options?.opts,
+      refreshInterval: options?.opts?.refreshInterval ?? 18e4 /* SLOW */
+    }
+  );
+  const [timestamp, setTimestamp] = useState3(Date.now());
+  useEffect3(() => {
+    if (!autoRefreshProposal) return;
+    const interval = setInterval(() => {
+      setTimestamp(Date.now() / 1e3);
+    }, 1e4 /* FAST */);
+    return () => clearInterval(interval);
+  }, []);
+  useEffect3(() => {
+    if (swrResponse.data === void 0) return;
+    switch (swrResponse.data.status) {
+      case ProposalStatus2.Pending:
+        if (timestamp >= Number(swrResponse.data.voteStartAt)) {
+          swrResponse.mutate();
+        }
+        break;
+      case ProposalStatus2.Active:
+        if (timestamp >= Number(swrResponse.data.voteEndAt)) {
+          swrResponse.mutate();
+        }
+        break;
+      case ProposalStatus2.InQueue:
+        if (Date.now() / 1e3 + 1 >= Number(swrResponse.data.queueEnd)) {
+          swrResponse.mutate();
+        }
+        break;
+    }
+  }, [swrResponse.data?.status, timestamp]);
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.()
+  };
+};
+
+// src/hooks/governance/usePollProposalThreshold.ts
+import useSWR4 from "swr";
+import { formatEther } from "viem";
+import { berachainGovernanceAbi as governanceAbi3 } from "@berachain/abis/gov/berachainGovernance";
+import { usePublicClient as usePublicClient6 } from "@berachain/wagmi/hooks";
+var usePollProposalThreshold = (governorAddress) => {
+  const publicClient = usePublicClient6();
+  const QUERY_KEY = publicClient ? ["usePollProposalThreshold", governorAddress] : null;
+  const swrResponse = useSWR4(
+    QUERY_KEY,
+    async ([, governorAddress2]) => {
+      assertPublicClient(publicClient);
+      const votesThreshold = await publicClient.readContract({
+        address: governorAddress2,
+        abi: governanceAbi3,
+        functionName: "proposalThreshold"
+      });
+      return { votesThreshold: formatEther(votesThreshold) };
+    },
+    {
+      refreshInterval: 18e4 /* SLOW */
+    }
+  );
+  return {
+    ...swrResponse,
+    refresh: swrResponse.mutate
+  };
+};
+
+// src/hooks/governance/usePollProposalVotes.ts
+import useSWRInfinite2 from "swr/infinite";
+var DEFAULT_LIMIT = 1e3;
+var usePollProposalVotes = (args, total) => {
+  return useSWRInfinite2(
+    usePollProposalVotesQueryKey(args, total),
+    async ([_key, page]) => {
+      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
+    }
+  );
+};
+var usePollProposalVotesQueryKey = ({ ...args }, total) => (pageIndex) => {
+  if (pageIndex > Math.floor(total / DEFAULT_LIMIT)) {
+    return null;
+  }
+  return [
+    "usePollProposalVotes",
+    pageIndex,
+    DEFAULT_LIMIT,
+    args.proposalId,
+    args.orderBy,
+    args.orderDirection
+  ];
+};
+
+// src/hooks/governance/usePollUserDelegates.ts
+import useSWR5 from "swr";
+import { formatEther as formatEther2 } from "viem";
+import { bgtAbi as bgtAbi2 } from "@berachain/abis/pol/bgt";
+import { useBeraWallet as useBeraWallet3, usePublicClient as usePublicClient7 } from "@berachain/wagmi/hooks";
+var usePollUserDelegates = (options) => {
+  const { address: account } = useBeraWallet3();
+  const publicClient = usePublicClient7();
+  const QUERY_KEY = account ? ["usePollUserDelegates", account] : null;
+  const swrResponse = useSWR5(
+    QUERY_KEY,
+    async ([, account2]) => {
+      assertPublicClient(publicClient);
+      const { config } = parseBaseArgs({
+        chainId: publicClient.chain.id
+      });
+      if (!publicClient || !account2) {
+        throw new Error("usePollUserDelegates needs publicClient and account");
+      }
+      const [delegate, currentVotes] = await Promise.all([
+        publicClient.readContract({
+          address: config.tokens.bgt,
+          abi: bgtAbi2,
+          functionName: "delegates",
+          args: [account2]
+        }),
+        publicClient.readContract({
+          address: config.tokens.bgt,
+          abi: bgtAbi2,
+          functionName: "getVotes",
+          args: [account2]
+        })
+      ]);
+      return {
+        delegate,
+        currentVotes: formatEther2(currentVotes)
+      };
+    },
+    {
+      ...options?.opts,
+      refreshInterval: options?.opts?.refreshInterval ?? 18e4 /* SLOW */
+    }
+  );
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.()
+  };
+};
+
+// src/hooks/governance/useProposalFromTx.ts
+import useSWR6 from "swr";
+import { usePublicClient as usePublicClient8, useTransactionReceipt } from "@berachain/wagmi/hooks";
+var useProposalFromTx = (txHash) => {
+  const { data: tx } = useTransactionReceipt({
+    hash: txHash
+  });
+  const publicClient = usePublicClient8();
+  const QUERY_KEY = tx && publicClient ? ["useProposalFromTx", txHash] : null;
+  const swrResponse = useSWR6(QUERY_KEY, async ([, txHash2]) => {
+    if (!tx) {
+      throw new Error("Transaction not found");
+    }
+    if (tx.transactionHash !== txHash2) {
+      throw new Error("Transaction hash mismatch");
+    }
+    return getProposalFromTx({ tx, publicClient });
+  });
+  return swrResponse;
+};
+
+// src/hooks/governance/useProposalState.ts
+import useSWRImmutable3 from "swr/immutable";
+import { berachainGovernanceAbi as governanceAbi4 } from "@berachain/abis/gov/berachainGovernance";
+import { usePublicClient as usePublicClient9 } from "@berachain/wagmi/hooks";
+var ProposalStateMap = {
+  [0 /* Pending */]: "pending",
+  [1 /* Active */]: "active",
+  [2 /* Canceled */]: "canceled",
+  [3 /* Defeated */]: "defeated",
+  [4 /* Succeeded */]: "succeeded",
+  [5 /* Queued */]: "queued",
+  [6 /* Expired */]: "expired",
+  [7 /* Executed */]: "executed"
+};
+var useProposalState = ({
+  proposalId,
+  governorAddress
+}) => {
+  const publicClient = usePublicClient9();
+  const QUERY_KEY = governorAddress && publicClient && proposalId ? ["useProposalState", proposalId] : null;
+  return useSWRImmutable3(QUERY_KEY, async ([, proposalId2]) => {
+    assertPublicClient(publicClient);
+    const snapshot = await publicClient.readContract({
+      abi: governanceAbi4,
+      address: governorAddress,
+      functionName: "state",
+      args: [BigInt(proposalId2)]
+    });
+    return ProposalStateMap[snapshot];
+  });
+};
+
+// src/hooks/governance/useProposalTimelockState.ts
+import useSWR7 from "swr";
+import { timeLockAbi as governanceTimelockAbi2 } from "@berachain/abis/gov/timeLock";
+import { usePublicClient as usePublicClient10 } from "@berachain/wagmi/hooks";
+var TimelockOperationState = {
+  0: "unset",
+  1: "waiting",
+  2: "ready",
+  3: "done"
+};
+function useProposalTimelockState({
+  proposalTimelockId,
+  timelockAddress
+}) {
+  const publicClient = usePublicClient10();
+  const QUERY_KEY = timelockAddress && publicClient && proposalTimelockId ? [
+    "useProposalTimelockState",
+    proposalTimelockId,
+    timelockAddress
+  ] : null;
+  return useSWR7(
+    QUERY_KEY,
+    async ([, proposalTimelockId2, timelockAddress2]) => {
+      assertPublicClient(publicClient);
+      const snapshot = await publicClient.readContract({
+        abi: governanceTimelockAbi2,
+        address: timelockAddress2,
+        functionName: "getOperationState",
+        args: [proposalTimelockId2]
+      });
+      return TimelockOperationState[snapshot];
+    },
+    {
+      refreshInterval: 18e4 /* SLOW */
+    }
+  );
+}
+
+// src/hooks/governance/useQuorum.ts
+import useSWR8 from "swr";
+import { usePublicClient as usePublicClient11 } from "@berachain/wagmi/hooks";
+
+// src/actions/governance/getQuorum.ts
+import { formatEther as formatEther3 } from "viem";
+import { berachainGovernanceAbi as governanceAbi5 } from "@berachain/abis/gov/berachainGovernance";
+async function getQuorum({
+  at,
+  publicClient,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  assertPublicClient(publicClient);
+  const quorum = await publicClient.readContract({
+    address: config.governance.governor,
+    abi: governanceAbi5,
+    functionName: "quorum",
+    // Needs to be pending or you'll get a ERC5805FutureLookup error when reading current quorum
+    // this is because now will always be in the future compared to the latest block
+    blockTag: "pending",
+    args: [BigInt(at ?? Math.floor(Date.now() / 1e3))]
+  });
+  return formatEther3(quorum);
+}
+
+// src/hooks/governance/useQuorum.ts
+function useQuorum({ at }, {
+  isEnabled = true
+}) {
+  const now = Math.floor(Date.now() / 1e3);
+  const publicClient = usePublicClient11();
+  const QUERY_KEY = isEnabled && publicClient ? [
+    "useQuorum",
+    // Using Now because we cannot query quorum in the future, so no need to have different query keys.
+    Number(at) > now ? "now" : at
+  ] : null;
+  const response = useSWR8(QUERY_KEY, async ([, at2]) => {
+    if (at2 === "now") {
+      return getQuorum({ publicClient });
+    }
+    return getQuorum({ at: at2, publicClient });
+  });
+  return {
+    ...response,
+    data: response.data ? Number(response.data) : void 0
+  };
+}
+export {
+  useCreateProposal,
+  useGetPastVotes,
+  useHasVoted,
+  useIsCanceller,
+  usePollAllProposals,
+  usePollAllProposalsQueryKey,
+  usePollProposal,
+  usePollProposalThreshold,
+  usePollProposalVotes,
+  usePollProposalVotesQueryKey,
+  usePollUserDelegates,
+  useProposalFromTx,
+  useProposalSnapshot,
+  useProposalState,
+  useProposalTimelockState,
+  useQuorum
+};