@berachain/berajs 0.2.8-beta.9 → 0.2.9

package/dist/hooks/governance/exports.d.ts

@@ -0,0 +1,181 @@
+import * as react from 'react';
+import { GovernanceTopic, CustomProposalErrors, CustomProposal } from '../../types/governance/exports.js';
+import * as swr from 'swr';
+import { SWRResponse } from 'swr';
+import { Address } from 'viem';
+import { P as POLLING } from '../../polling-BKnyavLI.js';
+import * as swr_infinite from 'swr/infinite';
+import { SWRInfiniteResponse, SWRInfiniteKeyLoader } from 'swr/infinite';
+import * as _berachain_graphql_governance from '@berachain/graphql/governance';
+import { Proposal_Filter, Proposal_OrderBy, OrderDirection, ProposalStatus, ProposalSelectionFragment, ProposalWithVotesFragment, GetProposalVotesQueryVariables } from '@berachain/graphql/governance';
+import { D as DefaultHookOptions, a as DefaultHookReturnType } from '../../global.d-BuGDKh4k.js';
+import * as swr__internal from 'swr/_internal';
+import '../../enum/governance/exports.js';
+import '@wagmi/core';
+import '@berachain/config';
+import '../../txnEnum-ByI5dtDi.js';
+import '../../BeraError-7-A5JYy_.js';
+
+declare const useCreateProposal: ({ initialData, currentTopic, onError, }: {
+    initialData?: any;
+    currentTopic: GovernanceTopic;
+    onError: (e: CustomProposalErrors) => void;
+}) => {
+    proposal: CustomProposal;
+    setProposal: react.Dispatch<react.SetStateAction<CustomProposal>>;
+    addProposalAction: () => void;
+    removeProposalAction: (idx: number) => void;
+    computeParamsAndErrors: () => readonly [`0x${string}`[], bigint[], `0x${string}`[], string] | undefined;
+};
+
+/**
+ * Returns the amount of voting power that a wallet had when the voting period began.
+ * {@link https://docs.openzeppelin.com/contracts/5.x/api/governance#Votes-getPastVotes-address-uint256-}
+ */
+declare const useGetPastVotes: (args: {
+    wallet?: Address;
+} & ({
+    proposalId?: bigint;
+    timepoint: number | bigint;
+} | {
+    proposalId: bigint;
+    timepoint?: number | bigint;
+})) => swr.SWRResponse<string, any, any>;
+
+declare const useHasVoted: ({ proposalId, wallet, }: {
+    proposalId: string;
+    wallet?: Address;
+}) => swr.SWRResponse<boolean, any, any>;
+
+declare const useIsCanceller: ({ account, ...baseArgs }: {
+    account: Address | undefined;
+} & BeraJS.BaseFunctionArgs) => swr.SWRResponse<boolean, any, {
+    refreshInterval: POLLING;
+    revalidateOnFocus: false;
+}>;
+
+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;
+declare function usePollAllProposalsQueryKey(topic: string, args?: Partial<UsePollAllProposalsArgs>): (pageIndex: number, previousPageData?: ProposalSelectionFragment[]) => PollAllProposalsKey;
+/**
+ * Fetch all proposals for a given topic
+ */
+declare function usePollAllProposals(args: UsePollAllProposalsArgs, options?: DefaultHookOptions & {
+    autoRefresh?: boolean;
+}): ProposalResult;
+
+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
+ */
+declare const usePollProposal: (proposalId: string, options?: DefaultHookOptions & {
+    autoRefresh?: boolean;
+}) => UsePollProposalResponse;
+
+declare const usePollProposalThreshold: (governorAddress: Address) => DefaultHookReturnType<{
+    votesThreshold: string;
+}>;
+
+type UsePollProposalVotesArgs = Omit<GetProposalVotesQueryVariables, "offset" | "limit">;
+/**
+ * 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
+ */
+declare const usePollProposalVotes: (args: UsePollProposalVotesArgs, total: number) => swr_infinite.SWRInfiniteResponse<{
+    data: _berachain_graphql_governance.GetProposalVotesQuery;
+}, any>;
+declare const usePollProposalVotesQueryKey: ({ ...args }: UsePollProposalVotesArgs, total: number) => SWRInfiniteKeyLoader;
+
+declare const usePollUserDelegates: (options?: DefaultHookOptions) => DefaultHookReturnType<{
+    delegate: Address;
+    currentVotes: string | undefined;
+}>;
+
+declare const useProposalFromTx: (txHash?: Address) => SWRResponse<ProposalWithVotesFragment | null>;
+
+/**
+ * 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-}
+ */
+declare const useProposalSnapshot: ({ proposalId, }: {
+    proposalId: number | bigint | string | undefined;
+}) => SWRResponse<string>;
+
+declare const useProposalState: ({ proposalId, governorAddress, }: {
+    proposalId: number | bigint | string | undefined;
+    governorAddress: Address;
+}) => SWRResponse<string>;
+
+declare const TimelockOperationState: {
+    readonly 0: "unset";
+    readonly 1: "waiting";
+    readonly 2: "ready";
+    readonly 3: "done";
+};
+/**
+ * Fetches the state of a proposal timelock
+ * @returns state of the proposal timelock (unset, waiting, ready, done)
+ */
+declare function useProposalTimelockState({ proposalTimelockId, timelockAddress, }: {
+    proposalTimelockId: Address | undefined;
+    timelockAddress: Address;
+}): SWRResponse<(typeof TimelockOperationState)[keyof typeof TimelockOperationState]>;
+
+/**
+ * Queries the quorum for a given timestamp.
+ *
+ * @returns current quorum if timestamp is in the future.
+ */
+declare function useQuorum({ at }: {
+    at: number | string;
+}, { isEnabled, }: {
+    isEnabled?: boolean;
+}): {
+    data: number | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<string>;
+    isValidating: boolean;
+    isLoading: swr__internal.IsLoadingResponse<Data, Config>;
+};
+
+export { type UsePollProposalResponse, useCreateProposal, useGetPastVotes, useHasVoted, useIsCanceller, usePollAllProposals, usePollAllProposalsQueryKey, usePollProposal, usePollProposalThreshold, usePollProposalVotes, usePollProposalVotesQueryKey, usePollUserDelegates, useProposalFromTx, useProposalSnapshot, useProposalState, useProposalTimelockState, useQuorum };