@berachain/berajs 0.2.12 → 0.3.0

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/{getApolloClient-MWm_iq4u.d.ts → actions/clients/BeraApolloClient.d.ts}

@@ -1,12 +1,11 @@
-import { ApolloClient, OperationVariables } from '@apollo/client';
-
+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.
  */
-declare class BeraApolloClient extends ApolloClient {
+export declare class BeraApolloClient extends ApolloClient {
     /**
      * The URL of the endpoint. Used for error reporting only.
      */
@@ -26,14 +25,4 @@ declare class BeraApolloClient extends ApolloClient {
         data: TData;
     }>;
 }
-
-/**
- * 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";
-declare function getApolloClient(clientName: GraphqlClient, { ...args }: BeraJS.BaseFunctionArgs): BeraApolloClient;
-
-export { BeraApolloClient as B, getApolloClient as g };
+//# 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;CA8EH"}

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

@@ -0,0 +1,10 @@
+/**
+ * Identifies the caller of a backend request for client-tracking metrics:
+ * `berachain.dapps` from a real dapp (hub/bend/honey), `berachain.berajs-test`
+ * in the test env, else `berachain.berajs` when berajs is consumed as a library.
+ *
+ * Used for both Stellate's GraphQL `x-graphql-client-name` and beep's
+ * `X-Client-Id` so the two stay in sync.
+ */
+export declare function getClientName(): string;
+//# sourceMappingURL=clientName.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clientName.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/clientName.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAMtC"}

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

@@ -1,62 +1,6 @@
-import { paths } from '@berachain/graphql/beep';
-import { HttpLink } from '@berachain/config';
-export { g as getApolloClient } from '../../getApolloClient-MWm_iq4u.js';
-export { gql } from '@apollo/client';
-
-/**
- * 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. */
-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`.
- */
-declare function fetchBeep<P extends GetPath<paths>>(path: P, params: DefinedParams<paths, P>, args?: BeraJS.BaseFunctionArgs): Promise<GetResponse<paths, P>>;
-
-export { fetchBeep, fetchOpenApi };
+export { fetchBeep } from "./fetchBeep";
+export { fetchEnso } from "./fetchEnso";
+export { fetchLayerzero } from "./fetchLayerzero";
+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,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EACL,eAAe,EACf,GAAG,GACJ,MAAM,mBAAmB,CAAC"}

package/dist/actions/clients/exports.mjs

@@ -1,19 +1,39 @@
-import {
-  fetchBeep,
-  fetchOpenApi
-} from "../../chunk-YLTWPFCJ.mjs";
 import {
   getApolloClient,
   gql
-} from "../../chunk-MKSFQIKC.mjs";
-import "../../chunk-T43JPYQS.mjs";
-import "../../chunk-DQRH5VE3.mjs";
-import "../../chunk-SZ5C44L5.mjs";
-import "../../chunk-RFJGL4MF.mjs";
-import "../../chunk-KHXJDYA4.mjs";
+} from "../../chunk-BZKA6DBM.mjs";
+import {
+  fetchBeep
+} from "../../chunk-7OESHTBN.mjs";
+import {
+  fetchLayerzero
+} from "../../chunk-J6GM7HWX.mjs";
+import {
+  fetchOpenApi
+} from "../../chunk-4576RF2K.mjs";
+import {
+  parseBaseArgs
+} from "../../chunk-SC3BSCTN.mjs";
+import "../../chunk-BMNEN4OK.mjs";
+import "../../chunk-LL7XR2H5.mjs";
+import "../../chunk-MVNQY2D4.mjs";
+
+// src/actions/clients/fetchEnso.ts
+import { appConfig } from "@berachain/config/internal";
+var isProduction = process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test";
+var ENSO_API_ORIGIN = "https://api.enso.build";
+function fetchEnso(path, params, args = {}) {
+  const { config } = parseBaseArgs(args);
+  const origin = isProduction ? `${config.bex.aggregatorsProxyUrl}/enso` : ENSO_API_ORIGIN;
+  const headers = isProduction ? void 0 : { Authorization: `Bearer ${appConfig.apiKeys.public.enso}` };
+  return fetchOpenApi(origin, path, params, "enso", headers);
+}
 export {
   fetchBeep,
+  fetchEnso,
+  fetchLayerzero,
   fetchOpenApi,
   getApolloClient,
   gql
 };
+//# sourceMappingURL=exports.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/clients/fetchEnso.ts"],"sourcesContent":["import { appConfig } from \"@berachain/config/internal\";\n\nimport type { paths } from \"@berachain/graphql/enso\";\n\nimport { parseBaseArgs } from \"../../utils/parseBaseArgs\";\nimport {\n  type DefinedParams,\n  fetchOpenApi,\n  type GetPath,\n  type GetResponse,\n} from \"./fetchOpenApi\";\n\nconst isProduction =\n  process.env.NODE_ENV !== \"development\" && process.env.NODE_ENV !== \"test\";\n\n/** Enso's public API origin. Schema paths already carry the `/api/v1` prefix. */\nconst ENSO_API_ORIGIN = \"https://api.enso.build\";\n\n/**\n * Typed GET against the Enso API.\n *\n * The `path`, its path/query params and the response are all type-checked\n * against the Enso schema (`@berachain/graphql/enso`). Base URL and auth mirror\n * {@link getEnsoClient}: in production requests go through the aggregators proxy\n * (which injects Enso auth), and in dev/test they hit Enso directly with the\n * public API key.\n *\n * Enso covers relay/bridge-check routes today, but callers should treat this as\n * \"the Enso implementation\" of those flows — if we later relay such txns\n * without Enso, swap the helper at the call site rather than generalizing this.\n */\nexport function fetchEnso<P extends GetPath<paths>>(\n  path: P,\n  params: DefinedParams<paths, P>,\n  args: BeraJS.BaseFunctionArgs = {},\n): Promise<GetResponse<paths, P>> {\n  const { config } = parseBaseArgs(args);\n\n  // Proxy in prod (auth handled by the proxy); direct + public key otherwise.\n  const origin = isProduction\n    ? `${config.bex.aggregatorsProxyUrl}/enso`\n    : ENSO_API_ORIGIN;\n  const headers = isProduction\n    ? undefined\n    : { Authorization: `Bearer ${appConfig.apiKeys.public.enso}` };\n\n  return fetchOpenApi<paths, P>(origin, path, params, \"enso\", headers);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,iBAAiB;AAY1B,IAAM,eACJ,QAAQ,IAAI,aAAa,iBAAiB,QAAQ,IAAI,aAAa;AAGrE,IAAM,kBAAkB;AAejB,SAAS,UACd,MACA,QACA,OAAgC,CAAC,GACD;AAChC,QAAM,EAAE,OAAO,IAAI,cAAc,IAAI;AAGrC,QAAM,SAAS,eACX,GAAG,OAAO,IAAI,mBAAmB,UACjC;AACJ,QAAM,UAAU,eACZ,SACA,EAAE,eAAe,UAAU,UAAU,QAAQ,OAAO,IAAI,GAAG;AAE/D,SAAO,aAAuB,QAAQ,MAAM,QAAQ,QAAQ,OAAO;AACrE;","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;AAIrD,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,CAMhC"}

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

@@ -0,0 +1,17 @@
+import type { paths } from "@berachain/graphql/enso";
+import { type DefinedParams, type GetPath, type GetResponse } from "./fetchOpenApi";
+/**
+ * Typed GET against the Enso API.
+ *
+ * The `path`, its path/query params and the response are all type-checked
+ * against the Enso schema (`@berachain/graphql/enso`). Base URL and auth mirror
+ * {@link getEnsoClient}: in production requests go through the aggregators proxy
+ * (which injects Enso auth), and in dev/test they hit Enso directly with the
+ * public API key.
+ *
+ * Enso covers relay/bridge-check routes today, but callers should treat this as
+ * "the Enso implementation" of those flows — if we later relay such txns
+ * without Enso, swap the helper at the call site rather than generalizing this.
+ */
+export declare function fetchEnso<P extends GetPath<paths>>(path: P, params: DefinedParams<paths, P>, args?: BeraJS.BaseFunctionArgs): Promise<GetResponse<paths, P>>;
+//# sourceMappingURL=fetchEnso.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetchEnso.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/fetchEnso.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGrD,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,OAAO,EACZ,KAAK,WAAW,EACjB,MAAM,gBAAgB,CAAC;AAQxB;;;;;;;;;;;;GAYG;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,CAYhC"}

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

@@ -0,0 +1,12 @@
+import type { paths } from "@berachain/graphql/layerzero";
+import { type DefinedParams, type GetPath, type GetResponse } from "./fetchOpenApi";
+/**
+ * Typed GET against the LayerZero Scan API.
+ *
+ * The `path`, its path/query params and the response are all type-checked
+ * against the LayerZero schema (`@berachain/graphql/layerzero`). The Scan API is
+ * public (no auth), so requests hit it directly — no proxy split like
+ * {@link fetchEnso}.
+ */
+export declare function fetchLayerzero<P extends GetPath<paths>>(path: P, params: DefinedParams<paths, P>): Promise<GetResponse<paths, P>>;
+//# sourceMappingURL=fetchLayerzero.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetchLayerzero.d.ts","sourceRoot":"","sources":["../../../src/actions/clients/fetchLayerzero.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAE1D,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,OAAO,EACZ,KAAK,WAAW,EACjB,MAAM,gBAAgB,CAAC;AAQxB;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,EACrD,IAAI,EAAE,CAAC,EACP,MAAM,EAAE,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,GAC9B,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAOhC"}

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

@@ -0,0 +1,51 @@
+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.
+ * @param headers  Request headers. Kept minimal by default — extra headers
+ *                 (e.g. `X-Client-Id`, which only beep needs) trigger a CORS
+ *                 preflight that third-party gateways like Enso reject.
+ */
+export declare function fetchOpenApi<Paths extends AnyPaths, P extends GetPath<Paths>>(link: HttpLink, path: P, params: DefinedParams<Paths, P>, fallbackName: string, headers?: Record<string, 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;;;;;;;;;;;GAWG;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,EACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAmChC"}

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;AAwBtD,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/aggregators/base.d.ts

@@ -0,0 +1,114 @@
+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[];
+    /**
+     * Whether this aggregator can handle a BERA↔WBERA pair.
+     *
+     * Most aggregators normalize native BERA → WBERA before routing (see
+     * `parseAddresses`), so a BERA↔WBERA pair collapses to WBERA↔WBERA and the
+     * external router rejects it as "same token" (e.g. Enso 400, HUB-9FQ). For
+     * those, `getUnsupportedReason` rejects the pair up-front so no request fires.
+     * Only the dedicated wrap/unwrap aggregator sets this `true`.
+     */
+    supportsBeraWrap: boolean;
+    /**
+     * Whether this aggregator can bridge — route a pair whose tokens live on
+     * different chains (`tokenIn.chainId !== tokenOut.chainId`).
+     *
+     * Most aggregators only route within a single chain; handed a cross-chain
+     * pair they would 400 or, worse, quote garbage against the wrong chain.
+     * `getUnsupportedReason` rejects such pairs up-front unless this is `true`.
+     * Only bridging aggregators (Enso via LayerZero) set it.
+     */
+    supportsBridging: boolean;
+    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>;
+    /**
+     * 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}`;
+    }[];
+    /**
+     * Returns a human-readable reason this aggregator can't route the pair, or
+     * `null` if it can. Callers gate on `=== null`; `assertChainSupport` throws
+     * the reason so users get an accurate message (not a misleading "does not
+     * support chain ID" for what is actually a same-token pair).
+     */
+    getUnsupportedReason({ tokenIn, tokenOut, }: {
+        tokenIn: Token;
+        tokenOut: Token;
+        honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+        underlyingToken?: Token | null;
+        rewardVault?: Address;
+    }): string | null;
+    assertChainSupport({ tokenIn, tokenOut, underlyingToken, honeyNativeState, }: {
+        tokenIn: Token;
+        tokenOut: Token;
+        underlyingToken?: Token | null;
+        honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+    }): 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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"}