@berachain/berajs 0.1.2 → 0.2.1

package/dist/{getValidatorQueuedOperatorAddress-9xY2RUGe.d.cts → getValidatorQueuedOperatorAddress-RW4OMcD1.d.ts}

@@ -1,8 +1,9 @@
 import { Address, PublicClient, Hex } from 'viem';
-import { GqlPoolType, GlobalDataQuery, ApiVaultFragment, GetVaultsQueryVariables, GqlChain, GqlVaultSnapshotDataRange, GetSWberaVaultSnapshotsQuery, GetVaultHistoryQueryVariables, GetVaultHistoryQuery, ApiValidatorFragment } from '@berachain/graphql/pol/api';
-import { h as TokenBalance, a as Token, P as PythLatestUpdates } from './HoneyConfigProvider-6PXZJMSU.cjs';
-import { P as ProtocolMetadata } from './staking-f4BpYH7l.cjs';
-import { GetPublicClientReturnType } from '@wagmi/core';
+import { BeraConfig, ChainId } from '@berachain/config/internal';
+import { I as IAggregatorArgs, g as IRawAggregatorQuote, b as Token, d as HoneyConfigContextReturn, B as BalanceToken, P as PythLatestUpdates } from './HoneyConfigProvider-CK6mOKFH.js';
+import { A as Aggregators } from './dex-C_BB0b0O.js';
+import { GqlPoolType, GlobalDataQuery, ApiVaultFragment, GetVaultsQueryVariables, GqlChain, GetVaultHistoryQueryVariables, GetVaultHistoryQuery, ApiValidatorFragment } from '@berachain/graphql/pol/api';
+import { P as ProtocolMetadata } from './global.d-wYu8G8IQ.js';
 
 interface GetConvertToAssetsProps {
     sharesAmount: bigint;
@@ -14,6 +15,90 @@ declare function getConvertToAssets({ sharesAmount, vaultAddress, publicClient,
     formatted: string;
 }>;
 
+declare abstract class BaseAggregator {
+    abstract name: Aggregators;
+    /**
+     * Supported chains for the aggregator.
+     * If null, the aggregator is supported on all chains.
+     */
+    abstract supportedChains: number[] | null;
+    static PATH_NOT_FOUND_REASON: string;
+    needsAccountForQuote: boolean;
+    notFoundMessages: string[];
+    config: BeraConfig;
+    chainId: ChainId;
+    constructor(args?: BeraJS.BaseFunctionArgs);
+    /**
+     * Identifies the url of the last sent request. Might not have all query params.
+     * Mainly used for error reporting.
+     */
+    url: string;
+    abstract readonly type: "rest" | "graphql" | "rpc";
+    abstract getQuote(args: IAggregatorArgs): Promise<IRawAggregatorQuote | undefined> | Promise<IRawAggregatorQuote | undefined>;
+    /**
+     * return wbera for native tokens to accomodate the aggregator's router logic
+     */
+    protected parseAddresses(tokenIn: string, tokenOut: string): {
+        tokenInAddress: Address;
+        tokenOutAddress: Address;
+        isTokenInNative: boolean;
+        isTokenOutNative: boolean;
+    };
+    /**
+     * Calculate input amount after fees.
+     *
+     * @returns Amount in wad format
+     */
+    protected getAmountAfterFees(amount: string, aggregatorsFeeBps?: number): string;
+    /**
+     * Formats input data for aggregator swaps
+     */
+    protected getInputData({ tokenIn, amountIn, isNative, isPermit2Approval, permit2SpenderAddress, }: {
+        tokenIn: Address;
+        amountIn: string;
+        isNative: boolean;
+        isPermit2Approval?: boolean;
+        permit2SpenderAddress?: Address | null;
+    }): {
+        tokenIn: `0x${string}`;
+        amountIn: bigint;
+        isNative: boolean;
+        isPermit2Approval: boolean;
+        permit2SpenderAddress: `0x${string}`;
+    };
+    /**
+     * Calculate min amount out
+     */
+    protected getMinAmountOut(amountOut: string, slippage: number): bigint;
+    protected parseAllowanceRequirements({ tokenIn, rawAmount, spender, }: {
+        tokenIn: Token;
+        rawAmount: string;
+        spender: Address;
+    }): {
+        token: Token;
+        amount: {
+            raw: string;
+            formatted: string;
+        };
+        spender: `0x${string}`;
+    }[];
+    /**
+     * Check if chain is supported
+     */
+    checkChainSupport({ tokenIn, tokenOut, }: {
+        tokenIn: Token;
+        tokenOut: Token;
+        honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+        underlyingToken?: Token | null;
+    }): boolean;
+    assertChainSupport({ tokenIn, tokenOut, underlyingToken, }: {
+        tokenIn: Token;
+        tokenOut: Token;
+        underlyingToken?: Token | null;
+    }): void;
+    protected fetch(url: string | URL, options?: RequestInit): Promise<Response>;
+}
+
 interface PoolStatus {
     isPoolInRecoveryMode: boolean;
     isPoolPaused: boolean;
@@ -67,7 +152,7 @@ interface GetVaultsBalancesArgs extends BeraJS.BaseFunctionArgs {
     collateralList: Token[];
     honeyFactoryAddress?: Address;
 }
-interface GetHoneyVaultsBalanceResponse extends TokenBalance {
+interface GetHoneyVaultsBalanceResponse extends BalanceToken {
     vault: Address;
 }
 declare function getHoneyVaultsBalance({ client, collateralList, honeyFactoryAddress, ...args }: GetVaultsBalancesArgs): Promise<GetHoneyVaultsBalanceResponse[]>;
@@ -269,24 +354,44 @@ interface GetGaugeData {
 }
 declare function getRewardVaults({ filter, publicClient, ...args }?: {
     filter?: GetVaultsQueryVariables;
-    publicClient?: GetPublicClientReturnType;
+    publicClient?: PublicClient | undefined;
 } & BeraJS.BaseFunctionArgs): Promise<GetGaugeData>;
 
-type GetStakedBeraSnapshotsArgs = {
-    chain?: GqlChain;
-    range?: GqlVaultSnapshotDataRange;
-} & BeraJS.BaseFunctionArgs;
+interface VaultMetadata {
+    current: {
+        exchangeRate: string;
+        totalSupply: string;
+        totalAssets: string;
+        tvl: string;
+    };
+    previous: {
+        exchangeRate: string;
+        totalSupply: string;
+        totalAssets: string;
+        tvl: string;
+    };
+    totalWBeraIssued: string;
+    lockPeriod?: number;
+    totalBuyBacks: number;
+    totalBuyBacksInLast24Hours: number;
+}
 /**
  *
+ * @param address - The address of the vault
  * @throws {Error} If the vault is not found
  * @returns
  */
-declare function getStakedBeraSnapshots({ chain, range, ...args }?: GetStakedBeraSnapshotsArgs): Promise<GetSWberaVaultSnapshotsQuery["polGetSWberaVaultSnapshots"]>;
+declare function getSWBeraVaultMetadata({ address, publicClient, blockTime, ...args }: {
+    address: Address;
+    publicClient?: PublicClient;
+    blockTime: number;
+} & BeraJS.BaseFunctionArgs): Promise<VaultMetadata>;
 
 /**
  * Interface representing a staked BERA withdrawal request
  */
 interface StakedBeraWithdrawal {
+    receiptTokenAddress: Address;
     withdrawalAmount?: bigint;
     timeRemaining?: string;
     withdrawalRequestId?: bigint;
@@ -304,7 +409,12 @@ interface StakedBeraWithdrawal {
  * @param version - The version of the stake vault contract ("V1" or "V2")
  * @returns Promise resolving to an array of withdrawal request information
  */
-declare function getSWBeraWithdrawal(contractAddress: Address, accountAddress: Address, publicClient: PublicClient, version: "V1" | "V2"): Promise<StakedBeraWithdrawal[]>;
+declare function getSWBeraWithdrawal({ contractAddress, accountAddress, publicClient, version, }: {
+    contractAddress: Address;
+    accountAddress: Address;
+    publicClient: PublicClient;
+    version: "V1" | "V2";
+}): Promise<StakedBeraWithdrawal[]>;
 
 interface UserVault {
     unclaimedBgt: string;
@@ -392,7 +502,7 @@ type UserBoostsOnValidator = {
 declare function getUserBoostsOnValidator({ account, pubkey, publicClient, ...args }: {
     account: Address;
     pubkey: Address;
-    publicClient: GetPublicClientReturnType;
+    publicClient: PublicClient | undefined;
 } & BeraJS.BaseFunctionArgs): Promise<UserBoostsOnValidator>;
 
 type ValidatorWithUserBoost = ApiValidatorFragment & {
@@ -400,7 +510,7 @@ type ValidatorWithUserBoost = ApiValidatorFragment & {
 };
 declare function getUserActiveValidators({ account, publicClient, chain, ...args }: {
     account: string;
-    publicClient?: GetPublicClientReturnType;
+    publicClient?: PublicClient | undefined;
     chain?: GqlChain;
 } & BeraJS.BaseFunctionArgs): Promise<ValidatorWithUserBoost[] | undefined>;
 
@@ -437,4 +547,4 @@ declare function getValidatorQueuedOperatorAddress({ client, pubKey, ...args }:
     pubKey: Address;
 } & BeraJS.BaseFunctionArgs): Promise<ValidatorQueuedOperatorAddress | undefined>;
 
-export { getVaultHistory as A, type ValidatorWithUserBoost as B, getUserActiveValidators as C, type UserBoostsOnValidator as D, getUserBoostsOnValidator as E, type UserStakingPoolPosition as F, type GetConvertToAssetsProps as G, getUserStakingPositions as H, type IsBadCollateralArgs as I, type ValidatorQueuedCommission as J, getValidatorQueuedCommission as K, type ValidatorQueuedOperatorAddress as L, getValidatorQueuedOperatorAddress as M, type ValidatorRewardAllocationRaw as N, type OnChainPool as O, type PoolStatus as P, type ValidatorRewardAllocationUpdate as Q, type RewardVaultIncentive as R, type StakedBeraWithdrawal as S, type ValidatorRewardAllocationUpdateWithExpiration as T, type UserVault as U, type ValidatorRewardAllocation as V, formatValidatorRewardAllocation as W, isSameRewardAllocation as X, getValidatorRewardAllocation as Y, getOnChainPool as a, getPoolPausedState as b, type GetHoneyVaultsBalanceResponse as c, getHoneyVaultsBalance as d, type IsBadCollateralResponse as e, type GetBgtAprSimulationArgs as f, getConvertToAssets as g, type GetBgtAprSimulationResult as h, isBadCollateralAsset as i, getBgtAprSimulation as j, type GlobalData as k, getGlobalData as l, type GetMarkets as m, getMarkets as n, getRewardVaultIncentives as o, RewardVaultDistributionMode as p, type GetRewardVaultRewardsReturn as q, getRewardVaultRewards as r, type GetGaugeData as s, getRewardVaults as t, type GetStakedBeraSnapshotsArgs as u, getStakedBeraSnapshots as v, getSWBeraWithdrawal as w, type GetUserVaultsResponse as x, getUserVaults as y, type GetVaultHistoryArgs as z };
+export { getVaultHistory as A, BaseAggregator as B, type ValidatorWithUserBoost as C, getUserActiveValidators as D, type UserBoostsOnValidator as E, getUserBoostsOnValidator as F, type GetConvertToAssetsProps as G, type UserStakingPoolPosition as H, type IsBadCollateralArgs as I, getUserStakingPositions as J, type ValidatorQueuedCommission as K, getValidatorQueuedCommission as L, type ValidatorQueuedOperatorAddress as M, getValidatorQueuedOperatorAddress as N, type OnChainPool as O, type PoolStatus as P, type ValidatorRewardAllocationRaw as Q, type RewardVaultIncentive as R, type StakedBeraWithdrawal as S, type ValidatorRewardAllocationUpdate as T, type UserVault as U, type ValidatorRewardAllocation as V, type ValidatorRewardAllocationUpdateWithExpiration as W, formatValidatorRewardAllocation as X, isSameRewardAllocation as Y, getValidatorRewardAllocation as Z, getOnChainPool as a, getPoolPausedState as b, type GetHoneyVaultsBalanceResponse as c, getHoneyVaultsBalance as d, type IsBadCollateralResponse as e, type GetBgtAprSimulationArgs as f, getConvertToAssets as g, type GetBgtAprSimulationResult as h, isBadCollateralAsset as i, getBgtAprSimulation as j, type GlobalData as k, getGlobalData as l, type GetMarkets as m, getMarkets as n, getRewardVaultIncentives as o, RewardVaultDistributionMode as p, type GetRewardVaultRewardsReturn as q, getRewardVaultRewards as r, type GetGaugeData as s, getRewardVaults as t, type VaultMetadata as u, getSWBeraVaultMetadata as v, getSWBeraWithdrawal as w, type GetUserVaultsResponse as x, getUserVaults as y, type GetVaultHistoryArgs as z };

package/dist/global.d-CN6l2b9E.d.cts

@@ -0,0 +1,473 @@
+import { Address, Hex, AbiFunction, Abi, ContractFunctionName, ContractFunctionArgs, TransactionReceipt, WalletCallReceipt, Account } from 'viem';
+import { ProposalWithVotesFragment, ProposalVoteFragment } from '@berachain/graphql/governance';
+import { b as ProposalTypeEnum, a as ProposalErrorCodes, T as TransactionActionType, C as ContractName } from './txnEnum-BlBYhNRl.cjs';
+import { a as TokenWithMetadata, b as Token } from './HoneyConfigProvider-Ca3ouozs.cjs';
+import { ApiValidatorFragment } from '@berachain/graphql/pol/api';
+import { Config, GetWalletClientReturnType } from '@wagmi/core';
+import { SWRConfiguration, SWRResponse } from 'swr';
+import { ChainId, BeraConfig } from '@berachain/config';
+import { B as BeraError } from './BeraError-_mQdkanr.cjs';
+
+type Proposal = ProposalWithVotesFragment;
+
+type Vote = ProposalVoteFragment;
+
+type Voter = Address;
+
+type ProposalVotes = {
+  yes: number;
+  no: number;
+  abstain: number;
+};
+
+type PROPOSAL_GENRE = "berahub" | "honey" | "bend" | "berps" | "general";
+
+type CustomProposalActionErrors = {
+  type?: null | ProposalErrorCodes;
+  target?: null | ProposalErrorCodes;
+  value?: null | ProposalErrorCodes;
+  ABI?: null | ProposalErrorCodes;
+  functionSignature?: null | ProposalErrorCodes;
+  args?: (null | ProposalErrorCodes)[];
+  vault?: null | ProposalErrorCodes;
+  isFriend?: null | ProposalErrorCodes;
+  to?: null | ProposalErrorCodes;
+  amount?: null | ProposalErrorCodes;
+  minIncentiveRate?: null | ProposalErrorCodes;
+  managerAddress?: null | ProposalErrorCodes;
+  input?: null | ProposalErrorCodes;
+  token?: null | ProposalErrorCodes;
+  rawCalldata?: null | ProposalErrorCodes;
+  message?: null | ProposalErrorCodes;
+} | null;
+
+type CustomProposalErrors = {
+  title?: null | ProposalErrorCodes;
+  description?: null | ProposalErrorCodes;
+  forumLink?: null | ProposalErrorCodes;
+  actions?: CustomProposalActionErrors[];
+};
+
+type GovernanceTopic = {
+  id: PROPOSAL_GENRE;
+  color: string;
+  icon: React.ReactNode;
+  iconBackground?: string;
+  name: string;
+  slug: string;
+  forumLink: string;
+  description?: string;
+  comingSoon?: boolean;
+};
+type CustomProposal = {
+  title: string;
+  description: any;
+  actions: ProposalAction[];
+  forumLink: string;
+  topic: Set<PROPOSAL_GENRE>;
+};
+
+type SafeProposalAction = {
+  value: bigint;
+  target: "" | Address;
+} & (
+  | {
+      type: ProposalTypeEnum.CUSTOM_PROPOSAL;
+      input: "ABI" | "rawCalldata" | "message";
+      ABI: string;
+      _isVerifiedAbi?: boolean;
+      functionSignature: string;
+      args: string[];
+      rawCalldata: Hex;
+      message: string;
+    }
+  | {
+      type:
+        | ProposalTypeEnum.WHITELIST_REWARD_VAULT
+        | ProposalTypeEnum.BLACKLIST_REWARD_VAULT;
+      vault: Address;
+    }
+  | {
+      type: ProposalTypeEnum.ERC20_TRANSFER;
+      to: Address;
+      amount: string;
+    }
+  | {
+      type: ProposalTypeEnum.WHITELIST_REWARD_VAULT_INCENTIVE;
+      vault: Address;
+      token: Address;
+      minIncentiveRate: string;
+      managerAddress: Address;
+    }
+);
+
+type ProposalAction = Partial<SafeProposalAction> & {
+  type: SafeProposalAction["type"];
+};
+
+type VerifiedAbi = {
+  abiItem?: AbiFunction;
+  functionName?: string;
+  args: readonly unknown[];
+  functionSignature?: string;
+};
+
+interface ProtocolMetadata {
+  name: string;
+  logoURI: string;
+  url: string;
+  description: string;
+  tags?: string[];
+}
+
+/**
+ * Configuration for a single staking option.
+ * Maps receipt tokens to their accepted input tokens.
+ */
+type StakingConfig = {
+  /** Unique identifier for this staking config */
+  id: string;
+  /** The token received when staking (e.g., sWBERA, siBERA) */
+  receiptToken: TokenWithMetadata;
+  /** Tokens that can be staked to receive the receipt token */
+  inputTokens: TokenWithMetadata[];
+};
+
+interface BribeBoostReward {
+  token: string;
+  total_unclaimed: string;
+}
+
+interface BribeBoostRewardItem {
+  rewards: BribeBoostReward[];
+  validator: string;
+}
+
+interface BribeBoostRewardProof {
+  validator?: string;
+  pagination: {
+    next: number;
+    previous: number;
+    record_per_page: number;
+    current_page: number;
+    total_page: number;
+  };
+  rewards:
+    | {
+        id: string;
+        dist_id: string;
+        token: Address;
+        recipient: string;
+        amount: string;
+        merkle_proof: string[];
+        available_at: number;
+      }[]
+    | null;
+}
+
+interface BribeBoostValidatorApr {
+  id: string;
+  boost_total_bgt: string;
+  rewards_total_usd: string;
+  daily_rate: string;
+  apr: string;
+  apy: string;
+  tokens: Address[]; // Confirm this type with backend real data
+  validator: string;
+  start_block: number;
+  end_block: number;
+  start_timestamp: number;
+  end_timestamp: number;
+  created_at: string;
+  updated_at: string;
+}
+
+type IncentiveReward = {
+  tokenMetadata: Token | undefined;
+  tokenPrice: number;
+  tokenValue: number;
+  id: string;
+  dist_id: string;
+  token: string;
+  recipient: string;
+  formattedAmount: string;
+  amount: string;
+  merkle_proof: string[];
+  available_at: number;
+};
+interface IncentiveRewardChunksWithValidatorData {
+  validator: ApiValidatorFragment | undefined;
+  maxTimestamp: number | undefined;
+  minTimestamp: number | undefined;
+  totalValue: number;
+  tokenTotals: {
+    chainId: number;
+    address: Address;
+    amount: number;
+    value: number;
+    metadata: Token | undefined;
+  }[];
+  rewards: IncentiveReward[];
+  isCurrent: boolean;
+}
+
+interface AggregatedTokenTotals {
+  address: Address;
+  amount: number;
+  value: number;
+  metadata: Token | undefined;
+  chainId: number;
+}
+
+type ClaimedIncentives = Record<string, string>;
+
+type ClaimedIncentivesLocalState = Record<string, ClaimedIncentives>;
+
+interface UserVaultInfo {
+  balance: bigint;
+  delegatedBalance: bigint;
+  withdrawableBalance: bigint;
+  rewards: string;
+  percentage: string;
+}
+
+type StakedBeraAsset = {
+  token: TokenWithMetadata;
+  apr: number;
+  stakedAmount: number;
+  stakedAmountUsd: number;
+  earnedAmount: number;
+  earnedAmountUsd: number;
+};
+
+interface UseContractWriteApi {
+    isLoading: boolean;
+    isSubmitting: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    write: IContractWriteFn;
+    reset: () => void;
+}
+type PropagatedArgs<args> = Omit<args, TxnEventKeys | "contractName"> & {
+    contractName?: string;
+};
+type TxnEventKeys = "onSuccess" | "onError" | "onLoading" | "onSubmission" | "onWarning";
+interface IUseContractWriteArgs<abi extends Abi | undefined = undefined, functionName extends abi extends Abi ? ContractFunctionName<abi> : never = abi extends Abi ? ContractFunctionName<abi> : never, params extends abi extends Abi ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName> : never = abi extends Abi ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName> : never> {
+    onSuccess?: (receipts: TransactionReceipt | WalletCallReceipt<bigint, "success" | "reverted">, 
+    /**
+     * Arguments that were used to call the write function.
+     */
+    writeArgs: PropagatedArgs<IContractWrite<abi, functionName, params>>) => void;
+    onError?: (e: BeraError, 
+    /**
+     * Arguments that were used to call the write function.
+     */
+    writeArgs: PropagatedArgs<IContractWrite<abi, functionName, params>>) => void;
+    onLoading?: (
+    /**
+     * Arguments that were used to call the write function.
+     */
+    writeArgs: PropagatedArgs<IContractWrite<abi, functionName, params>>) => void;
+    onSubmission?: (
+    /**
+     * @param args.id If request is a batch call, this will be the id of the request to the wallet provider
+     * @param args.txHash If request is a single transaction, this will be the hash of the transaction to wait for
+     */
+    args: {
+        txHash: Hex;
+        id?: never;
+    } | {
+        id: string;
+        txHash?: never;
+    }, 
+    /**
+     * Arguments that were used to call the write function.
+     */
+    writeArgs: PropagatedArgs<IContractWrite<abi, functionName, params>>) => void;
+    /**
+     * Callback function executed when a transaction encounters a warning. Transaction will still be submitted.
+     */
+    onWarning?: (e: BeraError, writeArgs: Omit<IContractWrite<abi, functionName, params>, TxnEventKeys>) => void;
+}
+
+type DefaultHookOptions = {
+  opts?: SWRConfiguration & { isEnabled?: boolean };
+};
+
+type DefaultHookReturnType<T = any> = Omit<
+  SWRResponse<T, any, any>,
+  "mutate"
+> & {
+  refresh: () => void;
+};
+
+type IContractWriteFn = <
+  abi extends Abi | undefined = undefined,
+  functionName extends abi extends Abi
+    ? ContractFunctionName<abi>
+    : never = abi extends Abi ? ContractFunctionName<abi> : never,
+  params extends abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never = abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never,
+>(
+  props: IContractWrite<abi, functionName, params>,
+) => Promise<
+  | TransactionReceipt
+  | WalletCallReceipt<bigint, "success" | "reverted">
+  | undefined
+>;
+
+/**
+ * Posthog must be able to serialize this. BigInts are not supported.
+ */
+type AllowedEventData = number | string | boolean | null | undefined;
+
+type EventData = Record<
+  string,
+  | AllowedEventData
+  | AllowedEventData[]
+  | Record<
+      string,
+      | AllowedEventData
+      | AllowedEventData[]
+      | Record<string, AllowedEventData | AllowedEventData[]>
+    >
+>;
+
+type IContractWrite<
+  abi extends Abi | undefined = undefined,
+  functionName extends abi extends Abi
+    ? ContractFunctionName<abi>
+    : never = abi extends Abi ? ContractFunctionName<abi> : never,
+  params extends abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never = abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never,
+> = {
+  /**
+   * A message that will be shown to user while the transaction is pending.
+   *
+   * @example "Sending approvals"
+   */
+  message: string;
+  /**
+   * The chain ID of the transaction.
+   *
+   * @default berachainChainId
+   */
+  chainId?: ChainId;
+  /**
+   * The type of transaction to be performed. It will be stored in the transaction history.
+   *
+   * Generally uses infinite tense.
+   * @example TransactionActionType.APPROVAL => "Approve tokens"
+   */
+  actionType: TransactionActionType;
+  txnName?: string;
+  gasLimit?: bigint;
+  account?: Account | Address;
+  /**
+   * Wheter the transaction can be sent by any account. Before setting this to true, make sure smart contract doesn't rely on `msg.sender`.
+   *
+   * Only transaction with permissionless flag set to true can be sent with overriden account.
+   * Everything else will throw an error.
+   */
+  permissionless?: boolean;
+  /**
+   * The event to be tracked more specifically.
+   * If not provided, the event will be tracked with the message and actionType.
+   */
+  track?: {
+    eventName: string;
+    eventData?: EventData;
+  };
+
+  /**
+   * A wagmi config used to get wallet clients, switch chains, etc.
+   *
+   * This is preferred over providing clients as state updates are kept synched in this config object w/o re-rendering.
+   */
+  wagmiConfig?: Config;
+
+  /**
+   * walletClient should only be provided for tests or scripts.
+   *
+   * Wagmi Config is preferred.
+   */
+  walletClient?: GetWalletClientReturnType | undefined;
+  /**
+   * The name of the contract to be used for the transaction. By default, it will be devrel's contract mapping.
+   * Custom values will be ignored if the address is already mapped in the devrel's contract mapping.
+   *
+   * @example "pol.rewardVault"
+   */
+  contractName?: ContractName;
+  /**
+   * This is a canonical list of ABIs that will be used to parse the error.
+   *
+   * This is an useful way to parse errors when providing raw data with no ABI.
+   */
+  errorsAbi?: Abi;
+} & IUseContractWriteArgs<abi, functionName, params> &
+  (abi extends Abi
+    ? {
+        abi: abi;
+        functionName: functionName;
+        params: params;
+        address: Address;
+        calls?: never;
+        value?: bigint;
+      }
+    :
+        | {
+            data: Hex;
+            address: Address;
+            value?: bigint;
+            calls?: never;
+          }
+        | {
+            value: bigint;
+            address: Address;
+            data?: Hex;
+            calls?: never;
+          }
+        | {
+            value?: never;
+            address?: never;
+            calls: (Omit<
+              IContractWrite,
+              | "calls"
+              | "gasLimit"
+              | "account"
+              | "address"
+              | "message"
+              | "actionType"
+              | TxnEventKeys
+            > & {
+              address: Address;
+            })[];
+          });
+
+declare global {
+  export namespace BeraJS {
+    export type BaseFunctionArgs = {
+      /**
+       * If only chainId is provided, config will be inferred from it
+       *
+       * @default `import { defaultChainId } from "@berachain/config/internal";`
+       */
+      chainId?: ChainId;
+      /**
+       * A config to infer the default values of the other arguments
+       *
+       * @default chainConfigs[chainId]
+       */
+      config?: BeraConfig;
+    };
+  }
+}
+
+export type { AggregatedTokenTotals as A, BribeBoostRewardProof as B, CustomProposal as C, DefaultHookOptions as D, GovernanceTopic as G, IContractWrite as I, ProtocolMetadata as P, StakingConfig as S, TxnEventKeys as T, UserVaultInfo as U, Vote as V, CustomProposalErrors as a, BribeBoostRewardItem as b, DefaultHookReturnType as c, StakedBeraAsset as d, IUseContractWriteArgs as e, UseContractWriteApi as f, BribeBoostReward as g, BribeBoostValidatorApr as h, IContractWriteFn as i, Proposal as j, Voter as k, ProposalVotes as l, PROPOSAL_GENRE as m, CustomProposalActionErrors as n, SafeProposalAction as o, ProposalAction as p, VerifiedAbi as q, IncentiveReward as r, IncentiveRewardChunksWithValidatorData as s, ClaimedIncentives as t, ClaimedIncentivesLocalState as u };