@berachain/berajs 0.2.11 → 0.2.13

package/dist/abi/utils/thirdwebMinimalAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thirdwebMinimalAccount.d.ts","sourceRoot":"","sources":["../../../src/abi/utils/thirdwebMinimalAccount.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAumBzB,CAAC"}

package/dist/abi/utils/upgradableBeacon.d.ts

@@ -0,0 +1,97 @@
+export declare const upgradableBeaconAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "initialOwner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "initialImplementation";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NewImplementationHasNoCode";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NewOwnerIsZeroAddress";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "Unauthorized";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "oldOwner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "OwnershipTransferred";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "implementation";
+        readonly type: "address";
+    }];
+    readonly name: "Upgraded";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "implementation";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "result";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "owner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "result";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "renounceOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "transferOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newImplementation";
+        readonly type: "address";
+    }];
+    readonly name: "upgradeTo";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+//# sourceMappingURL=upgradableBeacon.d.ts.map

package/dist/abi/utils/upgradableBeacon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgradableBeacon.d.ts","sourceRoot":"","sources":["../../../src/abi/utils/upgradableBeacon.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqFtB,CAAC"}

package/dist/actions/__test/transports.d.ts

@@ -0,0 +1,18 @@
+export declare const urls: string[];
+/**
+ * Thirdweb RPC URLs have a rate limit of 3 RPS.
+ * http() uses default viem transport which varies based on the chain definition.
+ *
+ * Quicknode RPC URLs are CORS restricted to *.berachain.com, *.berachain-staging.com. They have a 100rpm rate limit.
+ */
+export declare const testTransports: {
+    [x: number]: import("viem").FallbackTransport<import("viem").HttpTransport<undefined, false>[]> | import("viem").FallbackTransport<readonly [import("viem").HttpTransport<undefined, false>, import("viem").HttpTransport<undefined, false>]>;
+    1: import("viem").FallbackTransport<readonly [import("viem").HttpTransport<undefined, false>, import("viem").HttpTransport<undefined, false>]>;
+    137: import("viem").FallbackTransport<readonly [import("viem").HttpTransport<undefined, false>, import("viem").HttpTransport<undefined, false>]>;
+    10: import("viem").FallbackTransport<readonly [import("viem").HttpTransport<undefined, false>, import("viem").HttpTransport<undefined, false>]>;
+    8453: import("viem").FallbackTransport<readonly [import("viem").HttpTransport<undefined, false>, import("viem").HttpTransport<undefined, false>]>;
+    56: import("viem").FallbackTransport<readonly [import("viem").HttpTransport<undefined, false>, import("viem").HttpTransport<undefined, false>]>;
+    43114: import("viem").FallbackTransport<readonly [import("viem").HttpTransport<undefined, false>, import("viem").HttpTransport<undefined, false>]>;
+    42161: import("viem").FallbackTransport<readonly [import("viem").HttpTransport<undefined, false>, import("viem").HttpTransport<undefined, false>]>;
+};
+//# sourceMappingURL=transports.d.ts.map

package/dist/actions/__test/transports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transports.d.ts","sourceRoot":"","sources":["../../../src/actions/__test/transports.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,IAAI,EAAyC,MAAM,EAAE,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;CA8B1B,CAAC"}

package/dist/actions/bend/getConvertToAssets.d.ts

@@ -0,0 +1,11 @@
+import { type Address, type PublicClient } from "viem";
+export interface GetConvertToAssetsProps {
+    sharesAmount: bigint;
+    vaultAddress: Address;
+    publicClient: PublicClient;
+}
+export declare function getConvertToAssets({ sharesAmount, vaultAddress, publicClient, }: GetConvertToAssetsProps): Promise<{
+    raw: bigint;
+    formatted: string;
+}>;
+//# sourceMappingURL=getConvertToAssets.d.ts.map

package/dist/actions/bend/getConvertToAssets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getConvertToAssets.d.ts","sourceRoot":"","sources":["../../../src/actions/bend/getConvertToAssets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;AAIpE,MAAM,WAAW,uBAAuB;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,wBAAsB,kBAAkB,CAAC,EACvC,YAAY,EACZ,YAAY,EACZ,YAAY,GACb,EAAE,uBAAuB,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAQvE"}

package/dist/actions/bend/getMaxDeposit.d.ts

@@ -0,0 +1,26 @@
+import { type Address, type PublicClient } from "viem";
+interface GetMaxDepositProps {
+    vaultAddress: Address;
+    publicClient: PublicClient;
+}
+export interface MaxDeposit {
+    /** `maxDeposit` formatted as an ether-denominated decimal string. */
+    formatted: string;
+    /**
+     * True when the vault has no real deposit cap. MetaMorpho's `maxDeposit` sums
+     * each enabled market's remaining capacity (its supply cap minus current
+     * supply); an uncapped market stores `type(uint184).max` as its cap, so the
+     * sum lands at ~uint184.max (≈2.45e55) — not uint256.max. `formatted` turns
+     * that into an astronomical number, so callers must key off this flag, not
+     * the formatted value, to detect "unlimited".
+     *
+     * A genuine cap is many orders of magnitude smaller (e.g. Re7 HONEY's ~92M =
+     * ~9.2e25), so the uint184-based threshold cleanly separates the two. The sum
+     * can exceed uint184.max when several markets are uncapped, so we compare with
+     * `>=` rather than testing for the exact sentinel.
+     */
+    isUncapped: boolean;
+}
+export declare function getMaxDeposit({ vaultAddress, publicClient, }: GetMaxDepositProps): Promise<MaxDeposit>;
+export {};
+//# sourceMappingURL=getMaxDeposit.d.ts.map

package/dist/actions/bend/getMaxDeposit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMaxDeposit.d.ts","sourceRoot":"","sources":["../../../src/actions/bend/getMaxDeposit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;AAIpE,UAAU,kBAAkB;IAC1B,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;;;OAYG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAMD,wBAAsB,aAAa,CAAC,EAClC,YAAY,EACZ,YAAY,GACb,EAAE,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC,CAW1C"}

package/dist/actions/clients/BeraApolloClient.d.ts

@@ -0,0 +1,28 @@
+import { ApolloClient, type OperationVariables } from "@apollo/client";
+/**
+ * This is a wrapper around the ApolloClient that throws a BeraError if the query returns an error or no data.
+ *
+ * It's mostly a typescript helper that keeps data always defined since we use errorPolicy: "none" by default.
+ * Such setting will throw an error if the query returns an error, rather than returning an object with undefined data and an error property.
+ */
+export declare class BeraApolloClient extends ApolloClient {
+    /**
+     * The URL of the endpoint. Used for error reporting only.
+     */
+    protected url: string;
+    protected serviceName: string;
+    constructor(options: ApolloClient.Options & {
+        /**
+         * The URL of the endpoint. Used for error reporting only.
+         */
+        url: string;
+        /**
+         * The name of the graphql service. Used for error reporting only.
+         */
+        name: string;
+    });
+    query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Omit<ApolloClient.QueryOptions<TData, TVariables>, "errorPolicy">): Promise<{
+        data: TData;
+    }>;
+}
+//# sourceMappingURL=BeraApolloClient.d.ts.map

package/dist/actions/clients/BeraApolloClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeraApolloClient.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/BeraApolloClient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAGZ,KAAK,kBAAkB,EAExB,MAAM,gBAAgB,CAAC;AAQxB;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,YAAY;IAChD;;OAEG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC;IAEtB,SAAS,CAAC,WAAW,EAAE,MAAM,CAAC;gBAE5B,OAAO,EAAE,YAAY,CAAC,OAAO,GAAG;QAC9B;;WAEG;QACH,GAAG,EAAE,MAAM,CAAC;QACZ;;WAEG;QACH,IAAI,EAAE,MAAM,CAAC;KACd;IAOG,KAAK,CACT,KAAK,GAAG,OAAO,EACf,UAAU,SAAS,kBAAkB,GAAG,kBAAkB,EAG1D,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE,aAAa,CAAC,GACzE,OAAO,CAAC;QAET,IAAI,EAAE,KAAK,CAAC;KACb,CAAC;CA4EH"}

package/dist/actions/clients/exports.d.ts

@@ -1,78 +1,4 @@
-import { paths } from '@berachain/graphql/beep';
-import { HttpLink } from '@berachain/config';
-import { paths as paths$1 } from '@berachain/graphql/api';
-export { g as getApolloClient } from '../../getApolloClient-BcUTGFUb.js';
-export { gql } from '@apollo/client';
-
-/**
- * A minimal, fully-typed GET helper for our `openapi-typescript`-generated
- * backends. Both backends serve only GETs, so rather than a full OpenAPI client
- * we type a single `fetchOpenApi` against a schema's `paths` and wrap it per
- * backend (`fetchBeep`, `fetchRailwayBackend`).
- *
- * The `path`, its path/query params and the response body are all type-checked
- * against the schema, so route shapes can never drift out of sync with the
- * backend. Requests go through {@link beraFetchJson} so they keep the same
- * Sentry tracing, `RequestError` handling and URL sanitization as the rest of
- * the codebase.
- */
-/** Any `openapi-typescript` `paths` object. */
-type AnyPaths = Record<string, any>;
-/** Paths in a schema that expose a JSON GET response. */
-type GetPath<Paths extends AnyPaths> = {
-    [P in keyof Paths]: Paths[P] extends {
-        get: {
-            responses: {
-                200: {
-                    content: {
-                        "application/json": unknown;
-                    };
-                };
-            };
-        };
-    } ? P : never;
-}[keyof Paths];
-type GetParams<Paths extends AnyPaths, P extends GetPath<Paths>> = Paths[P]["get"] extends {
-    parameters: infer Params;
-} ? Params : never;
-type GetResponse<Paths extends AnyPaths, P extends GetPath<Paths>> = Paths[P]["get"]["responses"][200]["content"]["application/json"];
-type DefinedParams<Paths extends AnyPaths, P extends GetPath<Paths>> = {
-    [K in keyof GetParams<Paths, P> as GetParams<Paths, P>[K] extends never ? never : K]: GetParams<Paths, P>[K];
-};
-/**
- * Perform a typed GET against an OpenAPI backend.
- *
- * @param link    The backend `HttpLink`. The base URL and monitoring name are
- *                read from it.
- * @param path    An OpenAPI path template, e.g. `/v0/stake/{vault}/stats-by-day`.
- * @param params  Path and query params, typed from the schema for `path`.
- * @param fallbackName  Monitoring name to use when `link` is a bare string.
- */
-declare function fetchOpenApi<Paths extends AnyPaths, P extends GetPath<Paths>>(link: HttpLink, path: P, params: DefinedParams<Paths, P>, fallbackName: string): Promise<GetResponse<Paths, P>>;
-
-/**
- * Typed GET against the next-gen "beep" backend.
- *
- * The `path`, its path/query params and the response are all type-checked
- * against the beep schema (`@berachain/graphql/beep`), so route shapes (e.g.
- * the `/v0/stake/*` namespace) can never drift out of sync with the backend.
- * The base URL is resolved from `config.beep`.
- *
- * @throws if `config.beep` is not set for the active chain. Callers should only
- * reach for beep when `config.beep` is non-null.
- */
-declare function fetchBeep<P extends GetPath<paths>>(path: P, params: DefinedParams<paths, P>, args?: BeraJS.BaseFunctionArgs): Promise<GetResponse<paths, P>>;
-
-/**
- * Typed GET against the legacy Railway backend.
- *
- * The `path`, its path/query params and the response are all type-checked
- * against the Railway schema (`@berachain/graphql/api`). The base URL is
- * resolved from `config.backend`.
- *
- * @deprecated The Railway backend is being replaced by beep; prefer
- * {@link fetchBeep} where `config.beep` is available.
- */
-declare function fetchRailwayBackend<P extends GetPath<paths$1>>(path: P, params: DefinedParams<paths$1, P>, args?: BeraJS.BaseFunctionArgs): Promise<GetResponse<paths$1, P>>;
-
-export { fetchBeep, fetchOpenApi, fetchRailwayBackend };
+export { fetchBeep } from "./fetchBeep";
+export { fetchOpenApi } from "./fetchOpenApi";
+export { getApolloClient, gql, } from "./getApolloClient";
+//# sourceMappingURL=exports.d.ts.map

package/dist/actions/clients/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/exports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EACL,eAAe,EACf,GAAG,GACJ,MAAM,mBAAmB,CAAC"}

package/dist/actions/clients/exports.mjs

@@ -1,21 +1,20 @@
-import {
-  fetchBeep,
-  fetchOpenApi,
-  fetchRailwayBackend
-} from "../../chunk-MRQGHXAN.mjs";
 import {
   getApolloClient,
   gql
-} from "../../chunk-3JJLQ2JX.mjs";
-import "../../chunk-Y6THHG77.mjs";
-import "../../chunk-DQRH5VE3.mjs";
-import "../../chunk-SZ5C44L5.mjs";
-import "../../chunk-ZLTMIFCZ.mjs";
-import "../../chunk-KHXJDYA4.mjs";
+} from "../../chunk-PHYZRH4I.mjs";
+import {
+  fetchBeep,
+  fetchOpenApi
+} from "../../chunk-BSOWLS3W.mjs";
+import "../../chunk-ZWTGVIPJ.mjs";
+import "../../chunk-TGN55GKE.mjs";
+import "../../chunk-BMNEN4OK.mjs";
+import "../../chunk-P3YZ7F22.mjs";
+import "../../chunk-NZAH3SGT.mjs";
 export {
   fetchBeep,
   fetchOpenApi,
-  fetchRailwayBackend,
   getApolloClient,
   gql
 };
+//# sourceMappingURL=exports.mjs.map

package/dist/actions/clients/exports.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/actions/clients/fetchBeep.d.ts

@@ -0,0 +1,12 @@
+import type { paths } from "@berachain/graphql/beep";
+import { type DefinedParams, type GetPath, type GetResponse } from "./fetchOpenApi";
+/**
+ * Typed GET against the next-gen "beep" backend.
+ *
+ * The `path`, its path/query params and the response are all type-checked
+ * against the beep schema (`@berachain/graphql/beep`), so route shapes (e.g.
+ * the `/v0/stake/*` namespace) can never drift out of sync with the backend.
+ * The base URL is resolved from `config.beep`.
+ */
+export declare function fetchBeep<P extends GetPath<paths>>(path: P, params: DefinedParams<paths, P>, args?: BeraJS.BaseFunctionArgs): Promise<GetResponse<paths, P>>;
+//# sourceMappingURL=fetchBeep.d.ts.map

package/dist/actions/clients/fetchBeep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchBeep.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/fetchBeep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGrD,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,OAAO,EACZ,KAAK,WAAW,EACjB,MAAM,gBAAgB,CAAC;AAExB;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,EAChD,IAAI,EAAE,CAAC,EACP,MAAM,EAAE,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,EAC/B,IAAI,GAAE,MAAM,CAAC,gBAAqB,GACjC,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAIhC"}

package/dist/actions/clients/fetchOpenApi.d.ts

@@ -0,0 +1,48 @@
+import type { HttpLink } from "@berachain/config";
+/**
+ * A minimal, fully-typed GET helper for our `openapi-typescript`-generated
+ * `beep` backend. beep serves only GETs, so rather than a full OpenAPI client
+ * we type a single `fetchOpenApi` against a schema's `paths` and wrap it
+ * (`fetchBeep`).
+ *
+ * The `path`, its path/query params and the response body are all type-checked
+ * against the schema, so route shapes can never drift out of sync with the
+ * backend. Requests go through {@link beraFetchJson} so they keep the same
+ * Sentry tracing, `RequestError` handling and URL sanitization as the rest of
+ * the codebase.
+ */
+/** Any `openapi-typescript` `paths` object. */
+type AnyPaths = Record<string, any>;
+/** Paths in a schema that expose a JSON GET response. */
+export type GetPath<Paths extends AnyPaths> = {
+    [P in keyof Paths]: Paths[P] extends {
+        get: {
+            responses: {
+                200: {
+                    content: {
+                        "application/json": unknown;
+                    };
+                };
+            };
+        };
+    } ? P : never;
+}[keyof Paths];
+type GetParams<Paths extends AnyPaths, P extends GetPath<Paths>> = Paths[P]["get"] extends {
+    parameters: infer Params;
+} ? Params : never;
+export type GetResponse<Paths extends AnyPaths, P extends GetPath<Paths>> = Paths[P]["get"]["responses"][200]["content"]["application/json"];
+export type DefinedParams<Paths extends AnyPaths, P extends GetPath<Paths>> = {
+    [K in keyof GetParams<Paths, P> as GetParams<Paths, P>[K] extends never ? never : K]: GetParams<Paths, P>[K];
+};
+/**
+ * Perform a typed GET against an OpenAPI backend.
+ *
+ * @param link    The backend `HttpLink`. The base URL and monitoring name are
+ *                read from it.
+ * @param path    An OpenAPI path template, e.g. `/v0/stake/{vault}/stats-by-day`.
+ * @param params  Path and query params, typed from the schema for `path`.
+ * @param fallbackName  Monitoring name to use when `link` is a bare string.
+ */
+export declare function fetchOpenApi<Paths extends AnyPaths, P extends GetPath<Paths>>(link: HttpLink, path: P, params: DefinedParams<Paths, P>, fallbackName: string): Promise<GetResponse<Paths, P>>;
+export {};
+//# sourceMappingURL=fetchOpenApi.d.ts.map

package/dist/actions/clients/fetchOpenApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchOpenApi.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/fetchOpenApi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAKlD;;;;;;;;;;;GAWG;AAEH,+CAA+C;AAE/C,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEpC,yDAAyD;AACzD,MAAM,MAAM,OAAO,CAAC,KAAK,SAAS,QAAQ,IAAI;KAC3C,CAAC,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS;QACnC,GAAG,EAAE;YAAE,SAAS,EAAE;gBAAE,GAAG,EAAE;oBAAE,OAAO,EAAE;wBAAE,kBAAkB,EAAE,OAAO,CAAA;qBAAE,CAAA;iBAAE,CAAA;aAAE,CAAA;SAAE,CAAC;KAC3E,GACG,CAAC,GACD,KAAK;CACV,CAAC,MAAM,KAAK,CAAC,CAAC;AAEf,KAAK,SAAS,CACZ,KAAK,SAAS,QAAQ,EACtB,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,IACtB,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS;IAAE,UAAU,EAAE,MAAM,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,WAAW,CACrB,KAAK,SAAS,QAAQ,EACtB,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,IACtB,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,CAAC;AAIrE,MAAM,MAAM,aAAa,CAAC,KAAK,SAAS,QAAQ,EAAE,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,IAAI;KAC3E,CAAC,IAAI,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,GACnE,KAAK,GACL,CAAC,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/B,CAAC;AAEF;;;;;;;;GAQG;AAEH,wBAAgB,YAAY,CAAC,KAAK,SAAS,QAAQ,EAAE,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,EAC3E,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,CAAC,EACP,MAAM,EAAE,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,EAC/B,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAgChC"}

package/dist/actions/clients/fetchOpenApi.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fetchOpenApi.unit.test.d.ts.map

package/dist/actions/clients/fetchOpenApi.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchOpenApi.unit.test.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/fetchOpenApi.unit.test.ts"],"names":[],"mappings":""}

package/dist/actions/clients/getApolloClient.d.ts

@@ -0,0 +1,11 @@
+import { BeraApolloClient } from "./BeraApolloClient";
+export { gql } from "@apollo/client";
+/**
+ * Browser-reachable Apollo client factory for `api` and Bend's `whisk`
+ * endpoints. The pol subgraph client is server-only; browser data access goes
+ * through the typed `/api/pol/*` REST endpoints. Same auth shape as
+ * bend.whiskApi — non-public env values only resolve server-side.
+ */
+type GraphqlClient = "api" | "bend.whisk" | "pol.subgraph";
+export declare function getApolloClient(clientName: GraphqlClient, { ...args }: BeraJS.BaseFunctionArgs): BeraApolloClient;
+//# sourceMappingURL=getApolloClient.d.ts.map

package/dist/actions/clients/getApolloClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getApolloClient.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/getApolloClient.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAgCtD,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAuCrC;;;;;GAKG;AACH,KAAK,aAAa,GAAG,KAAK,GAAG,YAAY,GAAG,cAAc,CAAC;AAsB3D,wBAAgB,eAAe,CAC7B,UAAU,EAAE,aAAa,EACzB,EAAE,GAAG,IAAI,EAAE,EAAE,MAAM,CAAC,gBAAgB,GACnC,gBAAgB,CA0ClB"}

package/dist/actions/clients/getEnsoClient.d.ts

@@ -0,0 +1,11 @@
+import { EnsoClient } from "@ensofinance/sdk";
+export declare function getEnsoClient({ baseURL, ...args }?: BeraJS.BaseFunctionArgs & {
+    /**
+     * Override the Enso API base URL.
+     *
+     * - Omit (or pass `undefined`) → external proxy in production, direct in dev/test
+     * - Pass a URL string (e.g. `"/api/enso"`) → route through that proxy
+     */
+    baseURL?: string;
+}): EnsoClient;
+//# sourceMappingURL=getEnsoClient.d.ts.map

package/dist/actions/clients/getEnsoClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getEnsoClient.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/getEnsoClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAS9C,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EACP,GAAG,IAAI,EACR,GAAE,MAAM,CAAC,gBAAgB,GAAG;IAC3B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACb,cAcL"}

package/dist/actions/dex/__tests__/aggregators.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aggregators.unit.test.d.ts.map

package/dist/actions/dex/__tests__/aggregators.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregators.unit.test.d.ts","sourceRoot":"","sources":["../../../../src/actions/dex/__tests__/aggregators.unit.test.ts"],"names":[],"mappings":""}

package/dist/actions/dex/__tests__/allPools.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=allPools.integration.test.d.ts.map

package/dist/actions/dex/__tests__/allPools.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allPools.integration.test.d.ts","sourceRoot":"","sources":["../../../../src/actions/dex/__tests__/allPools.integration.test.ts"],"names":[],"mappings":""}

package/dist/actions/dex/__tests__/getOnChainPool.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getOnChainPool.unit.test.d.ts.map

package/dist/actions/dex/__tests__/getOnChainPool.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOnChainPool.unit.test.d.ts","sourceRoot":"","sources":["../../../../src/actions/dex/__tests__/getOnChainPool.unit.test.ts"],"names":[],"mappings":""}

package/dist/actions/dex/aggregators/base.d.ts

@@ -0,0 +1,89 @@
+import { type Address } from "viem";
+import type { BeraConfig, ChainId } from "@berachain/config/internal";
+import type { HoneyConfigContextReturn } from "../../../contexts/HoneyConfigProvider";
+import type { Aggregators } from "../../../enum/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote, Token } from "../../../types/dex";
+export 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: "NO_SWAP_PATHS";
+    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>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/actions/dex/aggregators/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/actions/dex/aggregators/base.ts"],"names":[],"mappings":"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"}

package/dist/actions/dex/aggregators/bex.d.ts

@@ -0,0 +1,26 @@
+import { ChainId } from "@berachain/config/internal";
+import { Aggregators } from "../../../enum/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote } from "../../../types/dex";
+import { BaseAggregator } from "./base";
+declare class BexAggregator extends BaseAggregator {
+    name: Aggregators;
+    supportedChains: ChainId[];
+    readonly url: string;
+    readonly type = "graphql";
+    /**
+     * Helper function to convert zero address to wrapped token address
+     */
+    private convertZeroToWrapped;
+    /**
+     * Helper to calculate price impact percentage
+     */
+    private calculatePriceImpact;
+    /**
+     * Helper to check for stale SOR prices
+     */
+    private checkStalePrices;
+    getQuote(args: IAggregatorArgs): Promise<IRawAggregatorQuote>;
+}
+export declare const bex: BexAggregator;
+export {};
+//# sourceMappingURL=bex.d.ts.map

package/dist/actions/dex/aggregators/bex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bex.d.ts","sourceRoot":"","sources":["../../../../src/actions/dex/aggregators/bex.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAIrD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG/E,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAOxC,cAAM,aAAc,SAAQ,cAAc;IACxC,IAAI,cAAwB;IAC5B,eAAe,YAAsC;IACrD,QAAQ,CAAC,GAAG,SAAmC;IAC/C,QAAQ,CAAC,IAAI,aAAa;IAE1B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAY5B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA0ClB,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA0HpE;AAED,eAAO,MAAM,GAAG,eAAsB,CAAC"}

package/dist/actions/dex/aggregators/bgt.d.ts

@@ -0,0 +1,17 @@
+import { ChainId } from "@berachain/config/internal";
+import { Aggregators } from "../../../enum/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote, MinimalERC20 } from "../../../types/dex";
+import { BaseAggregator } from "./base";
+declare class RedeemBgtAggregator extends BaseAggregator {
+    name: Aggregators;
+    supportedChains: ChainId[];
+    readonly type = "rpc";
+    checkChainSupport({ tokenIn, tokenOut, }: {
+        tokenIn: MinimalERC20;
+        tokenOut: MinimalERC20;
+    }): boolean;
+    getQuote({ tokenIn, amount, }: Omit<IAggregatorArgs, "slippage" | "feeBps" | "tokenOut" | "account">): Promise<IRawAggregatorQuote>;
+}
+export declare const bgtRedeem: RedeemBgtAggregator;
+export {};
+//# sourceMappingURL=bgt.d.ts.map

package/dist/actions/dex/aggregators/bgt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bgt.d.ts","sourceRoot":"","sources":["../../../../src/actions/dex/aggregators/bgt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAErD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,YAAY,EACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAExC,cAAM,mBAAoB,SAAQ,cAAc;IAC9C,IAAI,cAAyB;IAC7B,eAAe,YAAsC;IACrD,QAAQ,CAAC,IAAI,SAAS;IAEtB,iBAAiB,CAAC,EAChB,OAAO,EACP,QAAQ,GACT,EAAE;QACD,OAAO,EAAE,YAAY,CAAC;QACtB,QAAQ,EAAE,YAAY,CAAC;KACxB,GAAG,OAAO;IAaL,QAAQ,CAAC,EACb,OAAO,EACP,MAAM,GACP,EAAE,IAAI,CACL,eAAe,EACf,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAC/C,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA4BjC;AAED,eAAO,MAAM,SAAS,qBAA4B,CAAC"}