@berachain/berajs 0.1.0-alpha.0

package/dist/getValidatorQueuedOperatorAddress-DK2Xv19c.d.ts

@@ -0,0 +1,440 @@
+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 './dex-DreiokgL.js';
+import { P as ProtocolMetadata } from './staking-Cggi38So.js';
+import { GetPublicClientReturnType } from '@wagmi/core';
+
+interface GetConvertToAssetsProps {
+    sharesAmount: bigint;
+    vaultAddress: Address;
+    publicClient: PublicClient;
+}
+declare function getConvertToAssets({ sharesAmount, vaultAddress, publicClient, }: GetConvertToAssetsProps): Promise<{
+    raw: bigint;
+    formatted: string;
+}>;
+
+interface PoolStatus {
+    isPoolInRecoveryMode: boolean;
+    isPoolPaused: boolean;
+}
+declare function getPoolPausedState({ publicClient, poolAddress, }: {
+    publicClient: PublicClient;
+    poolAddress: Address;
+}): Promise<PoolStatus>;
+
+interface OnChainPool {
+    pausedState: PoolStatus;
+    address: Address;
+    id: Hex;
+    name: string;
+    poolTokens: [
+        /**
+         * The addresses of the tokens in the pool
+         */
+        readonly Address[],
+        /**
+         * The balances of the tokens in the pool
+         */
+        string[],
+        /**
+         * The last change block of the pool
+         */
+        number
+    ];
+    totalSupply: string;
+    swapFee: string;
+    decimals: number;
+    weights: readonly string[] | undefined;
+    version: any;
+    factory: Address;
+    type: GqlPoolType;
+    /**
+     * For example, if value is 300000n and precision is 1000n, the user-set amplification parameter would be 300000n / 1000n = 300n.
+     *
+     * The first number is the raw value, the second number is a boolean indicating if the amplification parameter is being updated, and the third number is the precision factor.
+     * @see https://github.com/balancer/docs-developers/blob/main/references/valuing-balancer-lp-tokens/pools/stablepools.md#getamplificationparameter
+     */
+    amplificationParameter: readonly [number, boolean, number] | undefined;
+}
+declare function getOnChainPool({ poolId, publicClient, ...args }: {
+    poolId: string;
+    publicClient: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<OnChainPool>;
+
+interface GetVaultsBalancesArgs extends BeraJS.BaseFunctionArgs {
+    client: PublicClient;
+    collateralList: Token[];
+    honeyFactoryAddress?: Address;
+}
+interface GetHoneyVaultsBalanceResponse extends TokenBalance {
+    vault: Address;
+}
+declare function getHoneyVaultsBalance({ client, collateralList, honeyFactoryAddress, ...args }: GetVaultsBalancesArgs): Promise<GetHoneyVaultsBalanceResponse[]>;
+
+interface IsBadCollateralArgs extends BeraJS.BaseFunctionArgs {
+    client: PublicClient;
+    collateral: Token;
+    latestPrices: PythLatestUpdates | undefined;
+    isPythWrapperEnabled: boolean;
+}
+interface IsBadCollateralResponse {
+    isBlacklisted: boolean;
+    isDepegged: boolean;
+}
+/**
+ * Checks if a given collateral asset is considered bad, either by being blacklisted or depegged.
+ *
+ * @param {Object} args - The arguments object.
+ * @param {PublicClient} args.client - The client used to interact with the blockchain.
+ * @param {Token} args.collateral - The collateral asset to check.
+ *
+ * @returns {Promise<IsBadCollateralResponse | undefined>} An object indicating if the collateral is blacklisted or depegged.
+ */
+declare function isBadCollateralAsset({ client, collateral, latestPrices, isPythWrapperEnabled, ...args }: IsBadCollateralArgs): Promise<IsBadCollateralResponse | undefined>;
+
+declare enum RewardVaultDistributionMode {
+    Duration = "duration",
+    TargetRate = "targetRate",
+    TargetApr = "targetApr"
+}
+interface GetRewardVaultRewardsReturn {
+    rewardsDuration: number;
+    manager: Address;
+    /**
+     * The amount of BGT that will be distributed per second
+     */
+    rewardRate: string;
+    /**
+     * The timestamp when rewards will be depleted
+     */
+    periodFinish: number;
+    /**
+     * The amount of BGT that will be distributed from now until the periodFinish timestamp
+     */
+    availableRewards: string;
+    /**
+     * The amount of BGT that will be distributed per second.
+     *
+     * If this is 0, the duration mode is active.
+     */
+    targetRewardsPerSecond: string;
+    /**
+     * The minimum reward duration for the target rate
+     */
+    minRewardDurationForTargetRate: number;
+    /**
+     * The current mode of the vault
+     */
+    mode: RewardVaultDistributionMode.Duration | RewardVaultDistributionMode.TargetRate;
+}
+declare function getRewardVaultRewards(address: Address, publicClient: PublicClient): Promise<GetRewardVaultRewardsReturn>;
+
+type GetBgtAprSimulationArgs = {
+    /**
+     * Staked TVL of the vault in USD.
+     *
+     * Null if not available
+     */
+    tvl: number | null;
+    /**
+     * Price of BGT in USD
+     */
+    bgtPrice: number;
+    /**
+     * Undistributed BGT rewards
+     */
+    availableRewards: number;
+    /**
+     * Finish period of the reward distribution in seconds
+     */
+    periodFinish: number;
+    /**
+     * Current duration of the reward distribution in seconds. This will be used if the reward rate is 0.
+     *
+     */
+    currentDuration: number;
+    /**
+     * Maximum reward duration in seconds
+     */
+    MAX_REWARD_DURATION: number;
+    /**
+     * Minimum reward duration in seconds
+     */
+    MIN_REWARD_DURATION: number;
+} & ({
+    /**
+     *
+     */
+    mode: RewardVaultDistributionMode.TargetApr;
+    apr: number;
+    /**
+     * Minimum reward duration for the target rate
+     */
+    minRewardDurationForTargetRate: number;
+} | {
+    /**
+     *
+     */
+    mode: RewardVaultDistributionMode.TargetRate;
+    rewardRate: number;
+    /**
+     * Minimum reward duration for the target rate
+     */
+    minRewardDurationForTargetRate: number;
+} | {
+    /**
+     *
+     */
+    mode: RewardVaultDistributionMode.Duration;
+    /**
+     * Duration of the reward distribution in seconds
+     */
+    duration: number;
+    rewardRate?: never;
+    /**
+     * Must be between MIN_REWARD_DURATION and MAX_REWARD_DURATION
+     */
+    minRewardDurationForTargetRate?: never;
+});
+type GetBgtAprSimulationResult = {
+    apr: number | null;
+    duration: number;
+    rewardRate: number;
+    periodFinish: number;
+    /**
+     * It's the input target rate for the target rate mode.
+     *
+     * If input was target apr, it will be the calculated reward rate.
+     *
+     * If input was duration, it will be null.
+     */
+    targetRate: string | null;
+    /**
+     * If the mode is changed, this will be the new mode. Null otherwise.
+     */
+    mode: RewardVaultDistributionMode | null;
+};
+declare function getBgtAprSimulation({ availableRewards, periodFinish, tvl, bgtPrice, MIN_REWARD_DURATION, MAX_REWARD_DURATION, ...args }: GetBgtAprSimulationArgs): GetBgtAprSimulationResult;
+
+type ReturnedFromQuery = GlobalDataQuery["polGetGlobalInfo"] & {
+    top3EmittingValidators: GlobalDataQuery["top3EmittingValidators"]["validators"];
+    allValidatorsCount: number;
+};
+interface GlobalInfo extends Partial<ReturnedFromQuery> {
+}
+
+interface GlobalData extends GlobalInfo {
+    globalCuttingBoard: ApiVaultFragment[] | undefined;
+    bgtTotalSupply: string | undefined;
+    bgtTotalBoosts: string | undefined;
+}
+declare function getGlobalData(publicClient: PublicClient): Promise<GlobalData>;
+
+interface GetMarkets {
+    marketList: ProtocolMetadata[];
+    marketDictionary: {
+        [key: string]: ProtocolMetadata;
+    };
+}
+declare function getMarkets(args?: BeraJS.BaseFunctionArgs): Promise<GetMarkets>;
+
+interface RewardVaultIncentive {
+    token: Address;
+    manager: Address;
+    minIncentiveRate: string;
+    incentiveRate: string;
+    remainingAmount: string;
+    symbol?: string;
+    /**
+     * Amount of tokens that needs approval before they can be added to the incentive.
+     *
+     * Anyone can just `transfer` ERC20 to the vault, but incentive manager need to send accountIncentives to turn on distribution.
+     */
+    pendingAmount: string;
+    decimals: number;
+}
+declare function getRewardVaultIncentives({ address, stakingToken, publicClient, }: {
+    address: Address;
+    stakingToken: Address;
+    publicClient: PublicClient;
+}): Promise<RewardVaultIncentive[]>;
+
+interface GetGaugeData {
+    gaugeList: ApiVaultFragment[];
+    pagination: {
+        currentPage: number;
+        totalCount: number;
+    };
+}
+declare function getRewardVaults({ filter, publicClient, ...args }?: {
+    filter?: GetVaultsQueryVariables;
+    publicClient?: GetPublicClientReturnType;
+} & BeraJS.BaseFunctionArgs): Promise<GetGaugeData>;
+
+type GetStakedBeraSnapshotsArgs = {
+    chain?: GqlChain;
+    range?: GqlVaultSnapshotDataRange;
+} & BeraJS.BaseFunctionArgs;
+/**
+ *
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+declare function getStakedBeraSnapshots({ chain, range, ...args }?: GetStakedBeraSnapshotsArgs): Promise<GetSWberaVaultSnapshotsQuery["polGetSWberaVaultSnapshots"]>;
+
+/**
+ * Interface representing a staked BERA withdrawal request
+ */
+interface StakedBeraWithdrawal {
+    withdrawalAmount?: bigint;
+    timeRemaining?: string;
+    withdrawalRequestId?: bigint;
+}
+/**
+ * Retrieves staked BERA withdrawal information for a given account
+ *
+ * This function handles both V1 and V2 versions of the stake vault contract:
+ * - V1: Uses a single withdrawal request per account
+ * - V2: Uses ERC721 tokens to represent multiple withdrawal requests per account
+ *
+ * @param contractAddress - The address of the stake vault contract
+ * @param accountAddress - The address of the account to check withdrawals for
+ * @param publicClient - Viem public client for blockchain interactions
+ * @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[]>;
+
+interface UserVault {
+    unclaimedBgt: string;
+    formattedBalance: string;
+    stakingTokenPrice: number | null;
+    vault: ApiVaultFragment;
+}
+type GetUserVaultsResponse = {
+    totalStakedValue: number;
+    totalBgtRewards: string;
+    vaults: UserVault[];
+};
+declare function getUserVaults({ account, publicClient, ...args }: {
+    account: Address;
+    publicClient: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<GetUserVaultsResponse>;
+
+type GetVaultHistoryArgs = {
+    vault: Address;
+    chain?: GqlChain;
+} & Omit<GetVaultHistoryQueryVariables, "vaultId" | "chain"> & BeraJS.BaseFunctionArgs;
+declare function getVaultHistory({ vault, chain, ...args }: GetVaultHistoryArgs): Promise<GetVaultHistoryQuery["polGetRewardVaultSnapshots"] | undefined>;
+
+interface ValidatorRewardAllocationRaw {
+    startBlock: bigint;
+    weights: readonly {
+        receiver: `0x${string}`;
+        percentageNumerator: bigint;
+    }[];
+}
+interface ValidatorRewardAllocation {
+    start: {
+        blockNumber: number;
+        timestamp: number;
+    };
+    weights: readonly {
+        receiver: `0x${string}`;
+        /**
+         * Weight percentage as a number between 0 and 1.
+         */
+        percentage: number;
+    }[];
+}
+interface ValidatorRewardAllocationUpdate {
+    active: ValidatorRewardAllocation["start"];
+    set: ValidatorRewardAllocation["start"];
+}
+interface ValidatorRewardAllocationUpdateWithExpiration extends ValidatorRewardAllocationUpdate {
+    expiresAtTs: number;
+}
+declare function formatValidatorRewardAllocation(raw: ValidatorRewardAllocationRaw, startTs: number): ValidatorRewardAllocation;
+declare function isSameRewardAllocation(a: ValidatorRewardAllocation, b: ValidatorRewardAllocation): boolean;
+declare function getValidatorRewardAllocation({ client, pubKey, ...args }: BeraJS.BaseFunctionArgs & {
+    client: PublicClient;
+    pubKey: Address;
+}): Promise<{
+    /**
+     * The active reward allocation for the validator.
+     */
+    activeRewardAllocation: ValidatorRewardAllocation;
+    /**
+     * The set reward allocation for the validator.
+     *
+     * It might differ from the active reward allocation if the validator hasn't updated
+     *  the reward allocation for more than the reward allocation inactivity block span.
+     */
+    setRewardAllocation: ValidatorRewardAllocation;
+    /**
+     * Whether the reward allocation is inactive so it falls back to the baseline reward allocation.
+     */
+    isBaseline: boolean;
+    isNeverSet: boolean;
+}>;
+
+type UserBoostsOnValidator = {
+    pubkey: Address;
+    activeBoostAmount: string;
+    queuedBoostAmount: string;
+    queuedBoostStartBlock: number;
+    queuedDropBoostAmount: string;
+    queuedDropBoostStartBlock: number;
+    hasPendingBoosts: boolean;
+    hasActiveBoosts: boolean;
+};
+declare function getUserBoostsOnValidator({ account, pubkey, publicClient, ...args }: {
+    account: Address;
+    pubkey: Address;
+    publicClient: GetPublicClientReturnType;
+} & BeraJS.BaseFunctionArgs): Promise<UserBoostsOnValidator>;
+
+type ValidatorWithUserBoost = ApiValidatorFragment & {
+    userBoosts: UserBoostsOnValidator;
+};
+declare function getUserActiveValidators({ account, publicClient, chain, ...args }: {
+    account: string;
+    publicClient?: GetPublicClientReturnType;
+    chain?: GqlChain;
+} & BeraJS.BaseFunctionArgs): Promise<ValidatorWithUserBoost[] | undefined>;
+
+interface StakingPoolAmount {
+    amount: bigint;
+    formattedAmount: string;
+}
+interface UserStakingPoolPosition {
+    validatorAddress: Address;
+    earning: number;
+    staked?: StakingPoolAmount;
+    rewards?: StakingPoolAmount;
+    queueData?: {
+        stake?: StakingPoolAmount[];
+        unstake?: (StakingPoolAmount & {
+            timestamp: number;
+        })[];
+    };
+}
+declare function getUserStakingPositions(account: Address): Promise<UserStakingPoolPosition[]>;
+
+interface ValidatorQueuedCommission {
+    blockNumberLast: number;
+    commissionRate: number;
+}
+declare function getValidatorQueuedCommission({ client, pubKey, ...args }: BeraJS.BaseFunctionArgs & {
+    client: PublicClient;
+    pubKey: Address;
+}): Promise<ValidatorQueuedCommission | undefined | null>;
+
+type ValidatorQueuedOperatorAddress = [bigint, string];
+declare function getValidatorQueuedOperatorAddress({ client, pubKey, ...args }: {
+    client: PublicClient;
+    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 };