@berachain/berajs 0.1.1 → 0.2.0

package/dist/{BeraError-D1HS_rbb.d.cts → BeraError-_mQdkanr.d.cts}

@@ -1,16 +1,23 @@
-import * as SentryType from '@sentry/nextjs';
 import { Abi } from 'viem';
 
+/**
+ * Severity levels for error reporting.
+ * Mirrors Sentry's SeverityLevel for compatibility, but owned by berajs
+ * so we don't depend on @sentry/nextjs.
+ */
+type SeverityLevel = "fatal" | "error" | "warning" | "log" | "info" | "debug";
+
 interface IBeraErrorArgs {
     message?: string;
     displayMessage?: string;
     cause?: unknown;
     reason?: string;
     chainId?: number;
+    fingerprint?: string[];
     /**
-     * The level of the error to be used for Sentry.
+     * The level of the error to be used for error reporting.
      */
-    level?: SentryType.SeverityLevel;
+    level?: SeverityLevel;
     tags?: {
         [key in TagsKey]?: Primitive;
     };
@@ -20,16 +27,28 @@ interface IBeraErrorArgs {
      */
     abi?: Abi;
 }
-/**
- * Copy pasted from sentry types
- */
 type Primitive = number | string | boolean | bigint | symbol | null | undefined;
 /**
  * An helper type to make sure we only use the allowed tags. Sync this with docs/errors.md
  */
 type TagsKey = "wallet.chain" | "wallet.connector" | "wallet.address" | "error.reason" | "operation.type" | "operation.key" | "operation.txn.functionName" | "operation.txn.to" | "operation.txn.status" | "operation.source.url" | "operation.source.name" | "operation.source.queryName" | "operation.source.type";
 /**
- * This is a generic error class that can be used to handle errors in the SDK.
+ * Base error class for the entire berajs SDK.
+ *
+ * All errors should be a BeraError or one of its subclasses. Unknown errors should be
+ * normalized via `initBeraError({ cause })`.
+ *
+ * Key design: the constructor runs an **automatic reason detection pipeline** when `reason`
+ * is not explicitly provided. It calls `parseViemError` on the `cause` to extract a
+ * machine-readable reason code (e.g. "NotEnoughBalance", "BAL#508", "UserRejectedRequestError").
+ * That reason is then matched against `errorMap.ts` to resolve a user-friendly `displayMessage`.
+ *
+ * This means: for most viem errors, you only need to pass `cause` and everything else
+ * (reason, displayMessage, level) is derived automatically.
+ *
+ * @see parseViemError — the reason extraction engine
+ * @see errorMap.ts — reason → displayMessage mapping
+ * @see initBeraError — normalizes any error into a BeraError (preferred entry point)
  */
 declare class BeraError extends Error {
     /**
@@ -54,6 +73,12 @@ declare class BeraError extends Error {
      * This is typically the error code can be found in the errorMap.ts file. I.e. NotEnoughBalance or BAL#508
      */
     reason: string | null;
+    /**
+     * The fingerprint for the error.
+     *
+     * This is typically used to group errors in Sentry.
+     */
+    fingerprint: string[] | undefined;
     private _tags;
     set tags(tags: {
         [key: string | TagsKey]: Primitive;
@@ -61,9 +86,9 @@ declare class BeraError extends Error {
     get tags(): {
         [key: string | TagsKey]: Primitive;
     };
-    level: SentryType.SeverityLevel;
+    level: SeverityLevel;
     extra: Record<string, unknown>;
-    constructor({ message: m, displayMessage: dm, cause, reason, level, abi, tags, chainId, }: IBeraErrorArgs);
+    constructor({ message: m, displayMessage: dm, cause, reason, level, abi, tags, chainId, fingerprint, }: IBeraErrorArgs);
 }
 
-export { BeraError as B, type IBeraErrorArgs as I };
+export { BeraError as B, type IBeraErrorArgs as I, type SeverityLevel as S };

package/dist/{BeraError-D1HS_rbb.d.ts → BeraError-_mQdkanr.d.ts}

@@ -1,16 +1,23 @@
-import * as SentryType from '@sentry/nextjs';
 import { Abi } from 'viem';
 
+/**
+ * Severity levels for error reporting.
+ * Mirrors Sentry's SeverityLevel for compatibility, but owned by berajs
+ * so we don't depend on @sentry/nextjs.
+ */
+type SeverityLevel = "fatal" | "error" | "warning" | "log" | "info" | "debug";
+
 interface IBeraErrorArgs {
     message?: string;
     displayMessage?: string;
     cause?: unknown;
     reason?: string;
     chainId?: number;
+    fingerprint?: string[];
     /**
-     * The level of the error to be used for Sentry.
+     * The level of the error to be used for error reporting.
      */
-    level?: SentryType.SeverityLevel;
+    level?: SeverityLevel;
     tags?: {
         [key in TagsKey]?: Primitive;
     };
@@ -20,16 +27,28 @@ interface IBeraErrorArgs {
      */
     abi?: Abi;
 }
-/**
- * Copy pasted from sentry types
- */
 type Primitive = number | string | boolean | bigint | symbol | null | undefined;
 /**
  * An helper type to make sure we only use the allowed tags. Sync this with docs/errors.md
  */
 type TagsKey = "wallet.chain" | "wallet.connector" | "wallet.address" | "error.reason" | "operation.type" | "operation.key" | "operation.txn.functionName" | "operation.txn.to" | "operation.txn.status" | "operation.source.url" | "operation.source.name" | "operation.source.queryName" | "operation.source.type";
 /**
- * This is a generic error class that can be used to handle errors in the SDK.
+ * Base error class for the entire berajs SDK.
+ *
+ * All errors should be a BeraError or one of its subclasses. Unknown errors should be
+ * normalized via `initBeraError({ cause })`.
+ *
+ * Key design: the constructor runs an **automatic reason detection pipeline** when `reason`
+ * is not explicitly provided. It calls `parseViemError` on the `cause` to extract a
+ * machine-readable reason code (e.g. "NotEnoughBalance", "BAL#508", "UserRejectedRequestError").
+ * That reason is then matched against `errorMap.ts` to resolve a user-friendly `displayMessage`.
+ *
+ * This means: for most viem errors, you only need to pass `cause` and everything else
+ * (reason, displayMessage, level) is derived automatically.
+ *
+ * @see parseViemError — the reason extraction engine
+ * @see errorMap.ts — reason → displayMessage mapping
+ * @see initBeraError — normalizes any error into a BeraError (preferred entry point)
  */
 declare class BeraError extends Error {
     /**
@@ -54,6 +73,12 @@ declare class BeraError extends Error {
      * This is typically the error code can be found in the errorMap.ts file. I.e. NotEnoughBalance or BAL#508
      */
     reason: string | null;
+    /**
+     * The fingerprint for the error.
+     *
+     * This is typically used to group errors in Sentry.
+     */
+    fingerprint: string[] | undefined;
     private _tags;
     set tags(tags: {
         [key: string | TagsKey]: Primitive;
@@ -61,9 +86,9 @@ declare class BeraError extends Error {
     get tags(): {
         [key: string | TagsKey]: Primitive;
     };
-    level: SentryType.SeverityLevel;
+    level: SeverityLevel;
     extra: Record<string, unknown>;
-    constructor({ message: m, displayMessage: dm, cause, reason, level, abi, tags, chainId, }: IBeraErrorArgs);
+    constructor({ message: m, displayMessage: dm, cause, reason, level, abi, tags, chainId, fingerprint, }: IBeraErrorArgs);
 }
 
-export { BeraError as B, type IBeraErrorArgs as I };
+export { BeraError as B, type IBeraErrorArgs as I, type SeverityLevel as S };

package/dist/HoneyConfigProvider-CK6mOKFH.d.ts

@@ -0,0 +1,390 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { Address, PublicClient, Abi, Hex } from 'viem';
+import { Token as Token$1 } from '@berachain/graphql/pol/api';
+import { SwapKind } from '@berachain-foundation/berancer-sdk';
+import { H as HoneySwapAction } from './honey-CYm0RWf4.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>;
+
+type MinimalERC20 = {
+  address: Address;
+  decimals: number;
+  symbol: string;
+  name: string;
+  chainId: number;
+};
+
+type TokenWithMetadata = MinimalERC20 & {
+  tags?: string[];
+  base64?: string;
+  logoURI?: string;
+};
+
+type Token = TokenWithMetadata & {
+  totalSupply?: string;
+  weight?: number | string | null;
+};
+
+interface TokenPriceInfo {
+  price: number;
+  updatedAt: number;
+  chainId: number;
+}
+
+type TokenCurrentPriceMap = Record<
+  Lowercase<Address> | string,
+  TokenPriceInfo | undefined
+>;
+
+interface TokenWithAmount extends Token {
+  amount: string;
+  exceeding?: boolean;
+}
+
+interface TokenWithPrice extends Token {
+  price: number;
+}
+
+interface BalanceToken extends Token {
+  balance: {
+    /**
+     * This is the string representation of the balance in wei.
+     *
+     * It can be safely parsed to a bigint, but we're returning it as a string to avoid serialization issues.
+     *
+     * @example "1200000000000000000"
+     */
+    raw: string;
+    /**
+     * This is the formatted representation of the balance in the token's decimals.
+     *
+     * @example "1.2"
+     */
+    formatted: string;
+  };
+  /**
+   * Price of the token in USD.
+   */
+  price?: number;
+  /**
+   * Balance value in USD.
+   * Calculated as balance * price.
+   */
+  usdValue?: number;
+}
+
+interface SwapRequest {
+  tokenIn: Address;
+  tokenOut: Address;
+  tokenInDecimals: number;
+  tokenOutDecimals: number;
+  amount: string;
+  wberaIsBera: boolean;
+  swapKind: SwapKind;
+}
+
+/**
+ * Object with properties to check the allowance of a token.
+ */
+interface AllowanceQueryItem {
+  token: MinimalERC20;
+  /**
+   * The amount of the token to approve.
+   */
+  amount: {
+    raw: string;
+    formatted: string;
+  };
+  /**
+   * The address to approve the tokens to.
+   */
+  spender: Address;
+}
+
+interface AllowanceToken extends AllowanceQueryItem {
+  /**
+   * The current allowance of the token.
+   */
+  allowance: {
+    raw: string;
+    formatted: string;
+  };
+  /**
+   * Whether the allowance is needed to perform the transaction.
+   */
+  needsApproval: boolean;
+}
+
+interface IUserPosition {
+  lpBalance?: BalanceToken;
+  tokenBalances?: Omit<BalanceToken, "chainId">[];
+  userSharePercentage?: number;
+  stakedBalance?: Pick<BalanceToken, "address" | "balance" | "usdValue">;
+  /**
+   * Just a utility to detect if there is a price for the LP token.
+   */
+  lpTokenPrice?: number;
+}
+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: MinimalERC20;
+  tokenOut: MinimalERC20;
+  /**
+   * Amount of tokenIn to swap in wei.
+   */
+  amount: string;
+  slippage: number;
+  account?: Address;
+  publicClient?: PublicClient;
+  aggregatorsFeeBps?: number;
+  proxyAggregatorsThroughVercel?: boolean;
+  referrer?: SwapReferrer;
+  /**
+   * If provided, the aggregator will swap to the underlying token and deposit it into the vault (tokenOut).
+   *
+   * The aggregator won't check if the tokenOut is an ERC4626 vault, so this needs to be asserted by the caller.
+   * This is used for Staked BERA/iBera and Bend Vaults.
+   */
+  underlyingToken?: MinimalERC20 | null;
+  /**
+   * If provided, the aggregator will stake into the reward vault after the swap.
+   */
+  rewardVault?: Address;
+  /**
+   * Only needed by the honey mint/redeem aggregator.
+   */
+  honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+};
+
+type Calldata = {
+  params?: readonly unknown[] | undefined;
+  functionName?: string;
+  abi?: Abi;
+  address: Address;
+  data?: Hex;
+  value: bigint;
+  gasLimit?: bigint;
+};
+
+type IRawAggregatorQuote = {
+  amountOut: string;
+  amountIn: string;
+  name: Aggregators;
+  allowanceRequirements: AllowanceQueryItem[];
+  /**
+   * True if it's bera wrap/unwrap or bgt redeem.
+   */
+  isNativeSwap?: boolean;
+  priceImpactPercentage?: number | null;
+  swapFeeBps: number;
+  getCalldata?: ({ account }: { account: Address }) => Calldata;
+};
+
+type IAggregatorQuote =
+  // no need to force to swapAndStake as type check is done on each getQuote
+  IRawAggregatorQuote & {
+    amountOut: string;
+    amountOutUsd: string;
+    amountIn: string;
+    amountInUsd: string;
+    priceImpactPercentage: number;
+    exchangeRate: number;
+    relativeLossPercentage: number;
+    isBest?: boolean;
+  };
+
+/**
+ * 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>;
+
+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;
+
+export { type AllowanceQueryItem as A, type BalanceToken as B, type CollateralRates as C, type IAggregatorQuote as D, type HoneySwapActions as H, type IAggregatorArgs as I, type MinimalERC20 as M, type PythLatestUpdates as P, type SwapRequest as S, type TokenWithOrder as T, type TokenWithMetadata as a, type Token as b, HoneyConfigContext as c, type HoneyConfigContextReturn as d, type HoneyConfigProviderProps as e, HoneyConfigProvider as f, type IRawAggregatorQuote as g, type PythPriceFeedMap as h, type TokenCurrentPriceMap as i, type AllowanceToken as j, type HoneyFeeMap as k, type CollateralRatesArgs as l, getHoneyFees as m, HoneyPreviewMethod as n, type HoneyPreviewArgs as o, type HoneyPreviewResult as p, type HoneyPreviewReadResult as q, getHoneyPreview as r, getPythLatestPrices as s, type TokenWithAmount as t, useHoneyConfig as u, type IUserPosition as v, type Calldata as w, type TokenPriceInfo as x, type TokenWithPrice as y, type BexStatus as z };