@berachain/berajs 0.1.0-alpha.0

package/dist/dex-BD7Bq3pJ.d.ts

@@ -0,0 +1,562 @@
+import { SwapKind } from '@berachain-foundation/berancer-sdk';
+import { Address, PublicClient, Hex, Abi, ContractFunctionName, ContractFunctionArgs, TransactionReceipt, WalletCallReceipt, Account } from 'viem';
+import { a as aggregatorsRouterAbi } from './aggregatorsRouter-Cny4B_MB.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { Token as Token$1 } from '@berachain/graphql/pol/api';
+import { Config, GetWalletClientReturnType } from '@wagmi/core';
+import { SWRConfiguration, SWRResponse } from 'swr';
+import { ChainId, BeraConfig } from '@berachain/config';
+import { T as TransactionActionType } from './txnEnum-Diichv9Z.js';
+import { B as BeraError } from './BeraError-CfcNTfpH.js';
+
+interface CollateralRates {
+    mintFee: number;
+    redeemFee: number;
+}
+interface HoneyFeeMap {
+    single: Record<Address, CollateralRates>;
+    basket: CollateralRates;
+}
+interface CollateralRatesArgs extends BeraJS.BaseFunctionArgs {
+    client: PublicClient;
+    collateralList: Token$1[];
+}
+/**
+ * Fetches the mint and redeem rates for all collateral tokens and calculates the weighted basket rates
+ * @param {Object} params - The parameters object
+ * @param {PublicClient} params.client - The Viem public client instance
+ * @param {Address[]} params.collateralList - Array of collateral token addresses
+ * @returns {Promise<HoneyFeeMap | undefined>} Object containing individual collateral rates and weighted basket rates,
+ * or undefined if the operation fails
+ */
+declare function getHoneyFees({ client, collateralList, ...args }: CollateralRatesArgs): Promise<HoneyFeeMap>;
+
+/**
+ * Interface representing the latest Pyth price updates
+ * @interface PythLatestUpdates
+ * @property {`0x${string}`[]} calldata - Array of hex-encoded calldata for price updates
+ * @property {string[]} prices - Array of formatted price strings
+ */
+interface PythLatestUpdates {
+    calldata: `0x${string}`[];
+    prices: string[];
+}
+/**
+ * Fetches the latest price updates from Pyth Network's Hermes service
+ * @param {Object} params - The parameters object
+ * @param {string[]} params.priceFeedId - Array of Pyth price feed IDs to fetch updates for
+ * @returns {Promise<PythLatestUpdates>} Promise resolving to the latest price updates
+ * @example
+ * ```ts
+ * const updates = await getPythLatestPrices({
+ *   priceFeedId: ["0x123...", "0x456..."]
+ * });
+ * ```
+ */
+declare function getPythLatestPrices({ priceFeedId, }: {
+    priceFeedId: string[];
+}): Promise<PythLatestUpdates>;
+
+declare enum HoneyPreviewMethod {
+    Mint = "previewMintHoney",
+    MintWithPrice = "previewMintHoneyWithPrices",
+    RequiredCollateral = "previewMintCollaterals",
+    RequiredCollateralWithPrice = "previewMintCollateralsWithPrices",
+    Redeem = "previewRedeemCollaterals",
+    RedeemWithPrice = "previewRedeemCollateralsWithPrices",
+    HoneyToRedeem = "previewRedeemHoney",
+    HoneyToRedeemWithPrice = "previewRedeemHoneyWithPrices"
+}
+interface HoneyPreviewArgs extends BeraJS.BaseFunctionArgs {
+    client: PublicClient;
+    collateral: Token;
+    collateralList: TokenWithOrder[];
+    amount: string;
+    method: HoneyPreviewMethod;
+    latestPrices?: PythLatestUpdates;
+    isPythWrapperEnabled: boolean;
+}
+interface HoneyPreviewResult {
+    collaterals: Record<Address, bigint>;
+    honey: bigint;
+}
+interface HoneyPreviewReadResult {
+    collaterals: bigint[];
+    honey: bigint;
+}
+/**
+ * Calculates preview amounts for Honey protocol operations including minting and redeeming.
+ * This function handles different preview methods to calculate either the amount of Honey tokens
+ * that can be minted with given collateral or the amount of collateral needed to mint/redeem Honey tokens.
+ *
+ * @param {Object} params - The parameters for the preview calculation
+ * @param {PublicClient} params.client - The Viem public client for blockchain interaction
+ * @param {Token} params.collateral - The primary collateral token being used
+ * @param {Address[]} params.collateralList - List of all supported collateral tokens
+ * @param {string} params.amount - The amount to calculate preview for (in token units)
+ * @param {HoneyPreviewMethod} params.method - The type of preview calculation to perform
+ * @param {PythLatestUpdates | undefined} params.latestPrices - Optional latest price updates from Pyth oracle
+ *
+ * @returns {Promise<HoneyPreviewResult | undefined>} An object containing:
+ *   - collaterals: Record mapping collateral token addresses to their respective amounts
+ *   - honey: The amount of Honey tokens involved in the operation
+ *
+ * @throws {Error} If there's an error during the contract interaction or calculation
+ */
+declare function getHoneyPreview({ client, collateral, collateralList, amount, method, latestPrices, isPythWrapperEnabled, ...baseArgs }: HoneyPreviewArgs): Promise<HoneyPreviewResult | undefined>;
+
+declare enum HoneySwapAction {
+    RESET_AMOUNTS = "RESET_AMOUNTS",
+    ACTION_TYPE_CHANGE = "ACTION_TYPE_CHANGE",
+    COLLATERALS_CHANGE = "COLLATERALS_CHANGE",
+    FROM_AMOUNT_CHANGE = "FROM_AMOUNT_CHANGE",
+    TO_AMOUNT_CHANGE = "TO_AMOUNT_CHANGE",
+    PREVIEW_CHANGE = "PREVIEW_CHANGE",
+    IS_BASKET_MODE_ENABLED_CHANGE = "IS_BASKET_MODE_ENABLED_CHANGE",
+    IS_TYPING_CHANGE = "IS_TYPING_CHANGE",
+    IS_SUBMITTING_CHANGE = "IS_SUBMITTING_CHANGE",
+    IS_LOADING_CHANGE = "IS_LOADING_CHANGE"
+}
+type PythPriceFeedMap = Record<Address, Hex>;
+type HoneySwapActions = {
+    type: HoneySwapAction.RESET_AMOUNTS;
+} | {
+    type: HoneySwapAction.ACTION_TYPE_CHANGE;
+    value: "mint" | "redeem";
+} | {
+    type: HoneySwapAction.COLLATERALS_CHANGE;
+    value: TokenWithOrder[];
+} | {
+    type: HoneySwapAction.FROM_AMOUNT_CHANGE;
+    index: number;
+    value: string;
+} | {
+    type: HoneySwapAction.TO_AMOUNT_CHANGE;
+    index: number;
+    value: string;
+} | {
+    type: HoneySwapAction.PREVIEW_CHANGE;
+    value: HoneyPreviewResult;
+    changedAsset: Address;
+} | {
+    type: HoneySwapAction.IS_BASKET_MODE_ENABLED_CHANGE;
+    value: boolean;
+} | {
+    type: HoneySwapAction.IS_TYPING_CHANGE;
+    value: boolean;
+} | {
+    type: HoneySwapAction.IS_SUBMITTING_CHANGE;
+    value: boolean;
+} | {
+    type: HoneySwapAction.IS_LOADING_CHANGE;
+    value: boolean;
+};
+
+declare const HoneyConfigContext: react.Context<HoneyConfigContextReturn | undefined>;
+type TokenWithOrder = TokenWithMetadata & {
+    order: number;
+};
+interface HoneyConfigContextReturn {
+    /**
+     * Map of the Pyth price feed ids for each collateral
+     */
+    priceFeedMap: PythPriceFeedMap;
+    /**
+     * This is the list of all the collaterals that are supported by the Honey protocol
+     */
+    collateralList: TokenWithOrder[];
+    /**
+     * This is the main collateral that is used to calculate the relative cap limit
+     */
+    referenceCollateral: TokenWithOrder;
+    /**
+     * An object that maps the redeem/mint rate for each collateral and the weighted rates for the basket mode
+     */
+    feeMap: HoneyFeeMap;
+    flags: {
+        /**
+         * If true, mint/redeem will also update pyth prices
+         */
+        isPythWrapperEnabled: boolean;
+    };
+    /**
+     * Honey protocol configs
+     */
+    protocol: {
+        /**
+         * Honey protocol paused state
+         */
+        isPaused: boolean;
+        /**
+         * The label for the Honey protocol paused message
+         */
+        pausedBannerLabel?: string;
+    };
+}
+interface HoneyConfigProviderProps extends HoneyConfigContextReturn {
+    children: React.ReactNode;
+}
+declare function HoneyConfigProvider({ children, ...props }: HoneyConfigProviderProps): react_jsx_runtime.JSX.Element;
+declare function useHoneyConfig(): HoneyConfigContextReturn;
+
+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;
+};
+interface TokenBalance {
+    address: Address;
+    /**
+     * Balance in wei, should be string to be serializable in JSON
+     */
+    balance: bigint | string;
+    formattedBalance: string;
+    /**
+     * Balance in USD
+     */
+    usdValue?: number;
+}
+interface AllowanceToken extends Token {
+    allowance: bigint;
+    formattedAllowance: string;
+}
+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[]>>>;
+/**
+ * A list of contract names that are not mapped in the devrel's contract mapping or that are generated by factories (e.g. RewardVault).
+ */
+declare enum ContractName {
+    ENSO_ROUTER = "enso.router",
+    POL_REWARD_VAULT = "pol.rewardVault",
+    BEX_POOL = "bex.pool",
+    ERC20 = "others.erc20",
+    BEX_EXPLOITED_FUND_DISTRIBUTOR = "bex.exploitedFundDistributor"
+}
+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 {
+        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;
+        };
+    }
+}
+
+type MinimalERC20 = {
+    address: Address;
+    decimals: number;
+    symbol: string;
+    name: string;
+};
+type TokenWithMetadata = MinimalERC20 & {
+    tags?: string[];
+    base64?: string;
+    logoURI?: string;
+    chainId?: number;
+};
+type Token = TokenWithMetadata & {
+    /**
+     * @deprecated
+     */
+    default?: boolean;
+    totalSupply?: string;
+    weight?: number | string | null;
+};
+interface TokenPriceInfo {
+    price: number;
+    updatedAt: number;
+}
+type TokenCurrentPriceMap = Record<Lowercase<Address> | string, TokenPriceInfo | undefined>;
+interface TokenWithAmount extends Token {
+    amount: string;
+}
+interface BalanceToken extends Token {
+    balance: bigint;
+    formattedBalance: string;
+    price?: number;
+}
+type BalanceTokenWithMetadata = BalanceToken & TokenWithMetadata;
+interface TokenInput extends Token {
+    amount: string;
+    exceeding: boolean;
+}
+interface SwapRequest {
+    tokenIn: Address;
+    tokenOut: Address;
+    tokenInDecimals: number;
+    tokenOutDecimals: number;
+    amount: string;
+    wberaIsBera: boolean;
+    swapKind: SwapKind;
+}
+interface IUserPosition {
+    lpBalance?: TokenBalance;
+    tokenBalances?: TokenBalance[];
+    userSharePercentage?: number;
+    stakedBalance?: TokenBalance;
+    /**
+     * Just a utility to detect if there is a price for the LP token.
+     */
+    lpTokenPrice?: number;
+}
+declare enum PoolCreationStep {
+    POOL_TYPE = "Pool Type",
+    SELECT_TOKENS = "Select Tokens",
+    DEPOSIT_LIQUIDITY = "Deposit Liquidity",
+    SET_PARAMETERS = "Set Parameters",
+    SET_INFO = "Set Info"
+}
+type BexStatus = {
+    protocol: {
+        /**
+         * If the whole protocol is paused (i.e. ~the~ vault contract) disable any functionality except withdrawing proportional
+         * liquidity (provided that pool's recovery mode is enabled). Specifically we disable swaps and pool creation.
+         */
+        isPaused: boolean;
+    };
+    /**
+     * Pool is undefined if pool status is still loading if no pool address was provided.
+     */
+    pool?: {
+        /**
+         * Pool should be put into recovery mode if tx are reverting on-chain to do with fee computation or pool exits.
+         * It reduces the computation needed to withdraw liquidity and does not charge protocol fees on exits while enabled.
+         *
+         * NOTE: that you can potentially still do regular exits/joins/etc in recovery mode, but if the flag is true will only
+         * present the safe exit option to the user in FE.
+         */
+        isInRecoveryMode: boolean;
+        /**
+         * If the pool is paused you cannot do anything unless you also enable recovery mode (then you can withdraw safely).
+         */
+        isPaused: boolean;
+        /**
+         * Disable withdrawals for a pool due to a combination of pool and vault statuses.
+         */
+        disablePoolWithdrawals: boolean;
+        /**
+         * Disable deposits for a pool due to a combination of pool and vault statuses.
+         */
+        disablePoolDeposits: boolean;
+    };
+};
+type IAggregatorArgs = {
+    tokenIn: string;
+    tokenOut: string;
+    tokenInDecimals?: number;
+    tokenOutDecimals?: number;
+    amount: string;
+    slippage: number;
+    account?: Address;
+    publicClient?: PublicClient;
+    aggregatorsFeeBps?: number;
+    proxyAggregatorsThroughVercel?: boolean;
+    referrer?: SwapReferrer;
+    /**
+     * If provided, the aggregator will stake into the reward vault after the swap.
+     */
+    rewardVault?: Address;
+    honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+};
+declare enum Aggregators {
+    Oogabooga = "Oogabooga",
+    Fly = "Fly",
+    HubPools = "Hub Pools",
+    Wrap = "Wrap",
+    Unwrap = "Unwrap",
+    KyberSwap = "KyberSwap",
+    OpenOcean = "OpenOcean",
+    Haiku = "Haiku",
+    Enso = "Enso",
+    RedeemBgt = "RedeemBgt",
+    Honey = "Honey"
+}
+type IRawAggregatorQuote<isRoutedThroughAggregator = true> = {
+    amountOut: string;
+    amountIn: string;
+    name: Aggregators;
+    spender: Address | undefined;
+    /**
+     * True if it's bera wrap/unwrap or bgt redeem.
+     */
+    isNativeSwap?: boolean;
+    priceImpactPercentage?: number;
+    swapFeeBps: number;
+    calldata?: isRoutedThroughAggregator extends true ? Omit<IContractWrite<typeof aggregatorsRouterAbi, "swap">, "message" | "actionType"> : {
+        params: readonly unknown[] | undefined;
+        functionName: string;
+        abi: Abi;
+        address: Address;
+        value?: bigint;
+    };
+};
+type IAggregatorQuote = IRawAggregatorQuote<false> & {
+    amountOut: string;
+    amountOutUsd: string;
+    amountIn: string;
+    amountInUsd: string;
+    priceImpactPercentage: number;
+    exchangeRate: number;
+    relativeLossPercentage: number;
+    isBest?: boolean;
+};
+declare enum SwapReferrer {
+    SWAP = "SWAP",
+    ZAP = "ZAP"
+}
+
+export { Aggregators as A, type BalanceToken as B, type CollateralRates as C, type DefaultHookOptions as D, type DefaultHookReturnType as E, type IUserPosition as F, type BalanceTokenWithMetadata as G, type HoneySwapActions as H, type IRawAggregatorQuote as I, type TokenPriceInfo as J, type IUseContractWriteArgs as K, type TxnEventKeys as L, type MinimalERC20 as M, type SwapRequest as N, type BexStatus as O, type PythLatestUpdates as P, type IContractWriteFn as Q, ContractName as R, SwapReferrer as S, type TokenWithOrder as T, type UseContractWriteApi as U, HoneySwapAction as V, type Token as a, type TokenWithMetadata as b, HoneyConfigContext as c, type HoneyConfigContextReturn as d, type HoneyConfigProviderProps as e, HoneyConfigProvider as f, type IAggregatorQuote as g, type TokenBalance as h, type IAggregatorArgs as i, type PythPriceFeedMap as j, type TokenCurrentPriceMap as k, type AllowanceToken as l, type IContractWrite as m, type HoneyFeeMap as n, type CollateralRatesArgs as o, getHoneyFees as p, HoneyPreviewMethod as q, type HoneyPreviewArgs as r, type HoneyPreviewResult as s, type HoneyPreviewReadResult as t, useHoneyConfig as u, getHoneyPreview as v, getPythLatestPrices as w, type TokenInput as x, PoolCreationStep as y, type TokenWithAmount as z };