@berachain/berajs 0.2.8-beta.9 → 0.2.10

package/src/errors/BeraError.ts

@@ -6,6 +6,7 @@ import { GENERAL_ERROR } from "./errorMap";
 import { findMatchingError } from "./getErrorMessage";
 import { parseViemError, rpcErrorToReason } from "./parseViemError";
 import type { SeverityLevel } from "./severity";
+import { reasonToSpanStatus, type SpanStatusType } from "./spanStatus";
 
 export interface IBeraErrorArgs {
   message?: string;
@@ -26,6 +27,12 @@ export interface IBeraErrorArgs {
    * Optional ABI to be used to parse the error.
    */
   abi?: Abi;
+  /**
+   * Span status for tracing. When set, the tracing adapter uses this to
+   * set the span status instead of a generic "internal_error".
+   * Auto-inferred from `reason` when not explicitly provided.
+   */
+  spanStatus?: SpanStatusType;
 }
 
 type Primitive = number | string | boolean | bigint | symbol | null | undefined;
@@ -123,6 +130,12 @@ export class BeraError extends Error {
 
   level: SeverityLevel = "error";
 
+  /**
+   * Span status for tracing providers.
+   * Auto-inferred from `reason` when not explicitly provided.
+   */
+  spanStatus?: SpanStatusType;
+
   extra: Record<string, unknown> = {};
 
   constructor({
@@ -135,6 +148,7 @@ export class BeraError extends Error {
     tags,
     chainId,
     fingerprint,
+    spanStatus,
   }: IBeraErrorArgs) {
     let message = m;
 
@@ -200,6 +214,19 @@ export class BeraError extends Error {
       this.level = "error";
     }
 
+    // ── Span status inference ───────────────────────────────────────────
+    // Priority:
+    //   1. Explicit `spanStatus` from caller
+    //   2. Cascaded from a BeraError cause
+    //   3. Auto-inferred from `reason` via reasonToSpanStatus()
+    if (spanStatus) {
+      this.spanStatus = spanStatus;
+    } else if (this.cause instanceof BeraError && this.cause.spanStatus) {
+      this.spanStatus = this.cause.spanStatus;
+    } else {
+      this.spanStatus = reasonToSpanStatus(this.reason);
+    }
+
     // ── displayMessage resolution ─────────────────────────────────────────
     // Priority:
     //   1. Explicit `displayMessage` passed by caller
@@ -243,13 +270,26 @@ export class BeraError extends Error {
       (process.env.NEXT_PUBLIC_IS_MONOBERA === "true" || currentDapp) &&
       process.env.NODE_ENV !== "test"
     ) {
-      console.group("BeraError thrown");
-      console.debug("Level", this.level);
-      console.debug("Reason", this.reason);
-      console.debug("Message", this.message);
-      console.debug("Display Message", this.displayMessage);
-      console.debug("Cause", this.cause);
-      console.groupEnd();
+      // `console.group`/`groupEnd` are not implemented in Vercel's edge
+      // runtime — calling them there throws a TypeError which masks the
+      // original error. Fall back to a single debug line in that case.
+      if (typeof console.group === "function") {
+        console.group("BeraError thrown");
+        console.debug("Level", this.level);
+        console.debug("Reason", this.reason);
+        console.debug("Message", this.message);
+        console.debug("Display Message", this.displayMessage);
+        console.debug("Cause", this.cause);
+        console.groupEnd();
+      } else {
+        console.debug("BeraError thrown", {
+          level: this.level,
+          reason: this.reason,
+          message: this.message,
+          displayMessage: this.displayMessage,
+          cause: this.cause,
+        });
+      }
     }
   }
 }

package/src/errors/BeraTracing.unit.test.ts

@@ -165,6 +165,71 @@ describe("BeraTracing", () => {
     });
   });
 
+  describe("span status adapter pattern", () => {
+    it("adapter handler can read spanStatus from BeraError", async () => {
+      const { BeraError } = await import("./BeraError.js");
+      const statuses: string[] = [];
+
+      // Simulates the Sentry adapter wrapper pattern
+      const adapterHandler = async (
+        _ctx: any,
+        callback: () => Promise<any>,
+      ) => {
+        try {
+          const result = await callback();
+          statuses.push("ok");
+          return result;
+        } catch (error) {
+          const status =
+            error instanceof BeraError && error.spanStatus
+              ? error.spanStatus
+              : "internal_error";
+          statuses.push(status);
+          throw error;
+        }
+      };
+
+      const unsub = BeraTracing.addSpanHandler(adapterHandler);
+
+      // Test: error with spanStatus propagates through
+      await expect(
+        BeraTracing.startSpan(
+          { name: "test", op: "test.op", attributes: {} },
+          async () => {
+            throw new BeraError({
+              message: "user cancelled",
+              reason: "UserRejectedRequestError",
+            });
+          },
+        ),
+      ).rejects.toThrow("user cancelled");
+
+      expect(statuses).toEqual(["cancelled"]);
+
+      // Test: success sets ok
+      statuses.length = 0;
+      await BeraTracing.startSpan(
+        { name: "test", op: "test.op", attributes: {} },
+        async () => "done",
+      );
+      expect(statuses).toEqual(["ok"]);
+
+      // Test: non-BeraError defaults to internal_error
+      statuses.length = 0;
+      await expect(
+        BeraTracing.startSpan(
+          { name: "test", op: "test.op", attributes: {} },
+          async () => {
+            throw new Error("plain error");
+          },
+        ),
+      ).rejects.toThrow("plain error");
+      expect(statuses).toEqual(["internal_error"]);
+
+      unsub();
+    });
+  });
+
   describe("Sentry.startSpan compatibility", () => {
     it("works with a handler that accepts (options, callback) like Sentry.startSpan", async () => {
       // Sentry.startSpan signature: <T>(options, callback: (span) => T) => T

package/src/errors/RequestError.ts

@@ -1,10 +1,12 @@
 import type { ErrorLike } from "@apollo/client";
 
 import { getUriFromLink } from "@berachain/config";
+import { bepolia } from "@berachain/config/bepolia";
 import { mainnet } from "@berachain/config/mainnet";
 
 import { BeraError, type IBeraErrorArgs } from "./BeraError";
 import { errorMsgMap } from "./errorMap";
+import { httpStatusToSpanStatus, reasonToSpanStatus } from "./spanStatus";
 
 /**
  * This is an error class that should be used to handle errors from fetch requests.
@@ -32,12 +34,16 @@ export class RequestError extends BeraError {
    */
   private queryRichfulDomains = [
     mainnet.bex.aggregatorsProxyUrl,
-    "https://api.fly.trade/aggregator/quote",
+    // covers both /aggregator/quote and /aggregator/transaction?quoteId=...
+    // (the transaction endpoint's quoteId would otherwise fragment grouping)
+    "https://api.fly.trade/aggregator",
     "https://open-api.openocean.finance/v4/bera/swap",
     // vercel internal proxy
     "/api/aggregators?aggregator",
     // bonder endpoints have date-based query params (e.g. ?start=2025-11-28)
-    mainnet.staking,
+    mainnet.backend,
+    // beep (next-gen backend) on testnet — same date-based bonder query params
+    bepolia.beep,
   ];
 
   statusCode: number | undefined;
@@ -104,6 +110,17 @@ export class RequestError extends BeraError {
       }
     }
 
+    // ── Span status inference ─────────────────────────────────────────
+    // Re-infer from reason since it may have been set after super() ran
+    // (e.g. NETWORK_ERROR → unavailable, RATE_LIMITED_429 → resource_exhausted).
+    if (!this.spanStatus && this.reason) {
+      this.spanStatus = reasonToSpanStatus(this.reason);
+    }
+    // Fall back to HTTP status code mapping when no reason-based status.
+    if (!this.spanStatus && this.statusCode) {
+      this.spanStatus = httpStatusToSpanStatus(this.statusCode);
+    }
+
     this.tags = {
       ...this.tags,
       "error.statusCode": this.statusCode,
@@ -196,14 +213,18 @@ export class RequestError extends BeraError {
       // - have a network error
       // - have CORS errors
       // the list is empirically collected from sentry error logs.
+      // The trailing "(host)" suffix is optional: some browsers/transports omit
+      // it (e.g. bare "Failed to fetch" / "Load failed"). We normalize all of
+      // them to a single NETWORK_ERROR reason so the variants group together,
+      // falling back to the endpoint url when no host is present in the message.
       const failedToFetchMatch = message.match(
-        /^(?:NetworkError when attempting to fetch resource\.|Failed to fetch|Load failed) \(([a-z0-9-.]+)\)$/,
+        /^(?:NetworkError when attempting to fetch resource\.|Failed to fetch|Load failed)(?: \(([a-z0-9-.]+)\))?$/,
       );
       if (failedToFetchMatch) {
         return {
           reason: RequestError.REASON_MAP.NETWORK_ERROR,
           message: message,
-          url: failedToFetchMatch[1],
+          url: failedToFetchMatch[1] ?? this.endpoint.url,
         };
       }
     }

package/src/errors/RequestError.unit.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+
+import { RequestError } from "./RequestError.js";
+
+describe("RequestError endpoint normalization (grouping)", () => {
+  it("strips query params from the fly.trade transaction endpoint so quoteId no longer fragments groups", () => {
+    const base = "https://api.fly.trade/aggregator/transaction";
+    const a = new RequestError({
+      response: undefined,
+      endpoint: {
+        url: `${base}?quoteId=aaaa-1111&estimateGas=false`,
+        type: "rest",
+      },
+    });
+    const b = new RequestError({
+      response: undefined,
+      endpoint: {
+        url: `${base}?quoteId=bbbb-2222&estimateGas=false`,
+        type: "rest",
+      },
+    });
+
+    expect(a.endpoint.url).toBe(base);
+    expect(b.endpoint.url).toBe(base);
+    expect(a.endpoint.url).toBe(b.endpoint.url);
+  });
+});
+
+describe("RequestError network-error normalization (grouping)", () => {
+  it.each([
+    "Failed to fetch",
+    "Load failed",
+    "NetworkError when attempting to fetch resource.",
+    "Failed to fetch (api.berachain.com)",
+  ])("normalizes %s to NETWORK_ERROR reason", (message) => {
+    const err = new RequestError({
+      response: undefined,
+      cause: new TypeError(message),
+      endpoint: { url: "https://api.berachain.com", type: "graphql" },
+    });
+
+    expect(err.reason).toBe(RequestError.REASON_MAP.NETWORK_ERROR);
+    expect(err.level).toBe("warning");
+  });
+
+  it("does not treat unrelated messages as network errors", () => {
+    const err = new RequestError({
+      response: undefined,
+      cause: new TypeError("Cannot read properties of undefined"),
+      endpoint: { url: "https://api.berachain.com", type: "graphql" },
+    });
+
+    expect(err.reason).not.toBe(RequestError.REASON_MAP.NETWORK_ERROR);
+  });
+});

package/src/errors/errorMap.ts

@@ -89,6 +89,14 @@ export const errorMsgMap = {
       errorMSG:
         "Nonce is too low. Your wallet might have unconfirmed transactions.",
     },
+    REPLACEMENT_UNDERPRICED: {
+      // Transient resubmission issue (gas bump too low). Not function-specific —
+      // normalizing the raw RPC string to this key collapses the per-function
+      // Sentry groups (functionName is still kept as a tag).
+      keywords: ["replacement transaction underpriced"],
+      errorMSG:
+        "Your wallet tried to replace a pending transaction without raising the gas enough. Please wait for the previous transaction to finish, or try again.",
+    },
     GAS_PRICE: {
       keywords: ["gasLimit"],
       errorMSG:

package/src/errors/exports.ts

@@ -12,4 +12,9 @@ export * from "./initBeraError";
 export * from "./NotFoundError";
 export * from "./RequestError";
 export type { SeverityLevel } from "./severity";
+export {
+  httpStatusToSpanStatus,
+  reasonToSpanStatus,
+  type SpanStatusType,
+} from "./spanStatus";
 export * from "./TransactionFailedError";

package/src/errors/getRevertReason.integration.test.ts

@@ -29,6 +29,7 @@ import { rewardVaultAbi } from "@berachain/abis/pol/rewards/rewardVault";
 
 import { getConfig } from "@berachain/wagmi/config";
 
+import { testTransports } from "../actions/__test/transports";
 import { beraWriteContract } from "../actions/transactions/beraWriteContract";
 import { ContractName } from "../enum/contracts";
 import { TransactionActionType } from "../enum/txnEnum";
@@ -414,10 +415,9 @@ describe("eip5972 transactions", () => {
     account: anvilMockAccount,
     chain: publicClient.chain!,
   });
+
   const beraWagmiConfig = getConfig({
-    transports: {
-      [publicClient.chain!.id]: http(getRpcUrls().publicJsonRpcUrl),
-    },
+    transports: testTransports,
     defaultChain: publicClient.chain!,
     thirdweb: { clientId: appConfig.apiKeys.public.thirdweb },
   });

package/src/errors/spanStatus.ts

@@ -0,0 +1,78 @@
+/**
+ * Span status codes for tracing.
+ * Mirrors Sentry's SpanStatusType for compatibility, but owned by berajs
+ * so we don't depend on @sentry/nextjs.
+ *
+ * @see https://develop.sentry.dev/sdk/foundations/transport/event-payloads/span/
+ */
+export type SpanStatusType =
+  | "ok"
+  | "cancelled"
+  | "unknown_error"
+  | "invalid_argument"
+  | "deadline_exceeded"
+  | "not_found"
+  | "already_exists"
+  | "permission_denied"
+  | "resource_exhausted"
+  | "failed_precondition"
+  | "aborted"
+  | "out_of_range"
+  | "unimplemented"
+  | "internal_error"
+  | "unavailable"
+  | "data_loss"
+  | "unauthenticated";
+
+/**
+ * Maps an HTTP status code to a span status.
+ */
+export function httpStatusToSpanStatus(code: number): SpanStatusType {
+  if (code >= 200 && code < 300) return "ok";
+  switch (code) {
+    case 400:
+      return "invalid_argument";
+    case 401:
+      return "unauthenticated";
+    case 403:
+      return "permission_denied";
+    case 404:
+      return "not_found";
+    case 409:
+      return "already_exists";
+    case 429:
+      return "resource_exhausted";
+    case 499:
+      return "cancelled";
+    case 501:
+      return "unimplemented";
+    case 503:
+      return "unavailable";
+    case 504:
+      return "deadline_exceeded";
+    default:
+      return code >= 500 ? "internal_error" : "unknown_error";
+  }
+}
+
+/**
+ * Maps a BeraError reason code to a span status.
+ * Returns undefined if no mapping exists (caller keeps existing spanStatus).
+ */
+export function reasonToSpanStatus(
+  reason: string | null,
+): SpanStatusType | undefined {
+  switch (reason) {
+    case "UserRejectedRequestError":
+    case "AtomicReadyWalletRejectedUpgradeError":
+      return "cancelled";
+    case "NO_SWAP_PATHS":
+      return "not_found";
+    case "RATE_LIMITED_429":
+      return "resource_exhausted";
+    case "NETWORK_ERROR":
+      return "unavailable";
+    default:
+      return undefined;
+  }
+}

package/src/errors/spanStatus.unit.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+
+import { httpStatusToSpanStatus, reasonToSpanStatus } from "./spanStatus.js";
+
+describe("httpStatusToSpanStatus", () => {
+  it("maps 2xx to ok", () => {
+    expect(httpStatusToSpanStatus(200)).toBe("ok");
+    expect(httpStatusToSpanStatus(201)).toBe("ok");
+    expect(httpStatusToSpanStatus(204)).toBe("ok");
+  });
+
+  it("maps specific 4xx codes", () => {
+    expect(httpStatusToSpanStatus(400)).toBe("invalid_argument");
+    expect(httpStatusToSpanStatus(401)).toBe("unauthenticated");
+    expect(httpStatusToSpanStatus(403)).toBe("permission_denied");
+    expect(httpStatusToSpanStatus(404)).toBe("not_found");
+    expect(httpStatusToSpanStatus(409)).toBe("already_exists");
+    expect(httpStatusToSpanStatus(429)).toBe("resource_exhausted");
+    expect(httpStatusToSpanStatus(499)).toBe("cancelled");
+  });
+
+  it("maps specific 5xx codes", () => {
+    expect(httpStatusToSpanStatus(500)).toBe("internal_error");
+    expect(httpStatusToSpanStatus(501)).toBe("unimplemented");
+    expect(httpStatusToSpanStatus(503)).toBe("unavailable");
+    expect(httpStatusToSpanStatus(504)).toBe("deadline_exceeded");
+  });
+
+  it("maps unknown 4xx to unknown_error", () => {
+    expect(httpStatusToSpanStatus(418)).toBe("unknown_error");
+  });
+
+  it("maps unknown 5xx to internal_error", () => {
+    expect(httpStatusToSpanStatus(502)).toBe("internal_error");
+  });
+});
+
+describe("reasonToSpanStatus", () => {
+  it("maps user rejection reasons to cancelled", () => {
+    expect(reasonToSpanStatus("UserRejectedRequestError")).toBe("cancelled");
+    expect(reasonToSpanStatus("AtomicReadyWalletRejectedUpgradeError")).toBe(
+      "cancelled",
+    );
+  });
+
+  it("maps NO_SWAP_PATHS to not_found", () => {
+    expect(reasonToSpanStatus("NO_SWAP_PATHS")).toBe("not_found");
+  });
+
+  it("maps RATE_LIMITED_429 to resource_exhausted", () => {
+    expect(reasonToSpanStatus("RATE_LIMITED_429")).toBe("resource_exhausted");
+  });
+
+  it("maps NETWORK_ERROR to unavailable", () => {
+    expect(reasonToSpanStatus("NETWORK_ERROR")).toBe("unavailable");
+  });
+
+  it("returns undefined for unknown reasons", () => {
+    expect(reasonToSpanStatus("SomeOtherError")).toBeUndefined();
+    expect(reasonToSpanStatus(null)).toBeUndefined();
+  });
+});

package/src/hooks/dex/useCreatePool.ts

@@ -1,23 +1,9 @@
 import { useMemo } from "react";
 import { PoolType } from "@berachain-foundation/berancer-sdk";
-import useSWRImmutable from "swr/immutable";
-import {
-  type Address,
-  formatUnits,
-  keccak256,
-  parseUnits,
-  zeroAddress,
-} from "viem";
+import { type Address, keccak256, parseUnits, zeroAddress } from "viem";
 
 import { poolCreationHelperAbi as balancerPoolCreationHelperAbi } from "@berachain/abis/bex/poolCreationHelper";
 
-import {
-  GetDedupedSubgraphPools,
-  type GetDedupedSubgraphPoolsQuery,
-  type SubgraphPoolFragment,
-} from "@berachain/graphql/dex/subgraph";
-
-import { getApolloClient } from "../../actions/clients/getApolloClient";
 import { TransactionActionType } from "../../enum/txnEnum";
 import type { Token, TokenWithAmount } from "../../types/dex";
 import type { IContractWrite } from "../../types/global";
@@ -25,9 +11,7 @@ import { DEFAULT_METAMASK_GAS_LIMIT } from "../../utils/constants";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
 import { generatePoolName, generatePoolSymbol } from "../../utils/poolNamings";
 import { isToken } from "../../utils/tokens";
-import { wrapNativeTokens } from "../../utils/tokenWrapping";
 
-const DEFAULT_WEIGHTS_DUPLICATION_THRESHOLD = 0.005;
 interface UseCreatePoolProps extends BeraJS.BaseFunctionArgs {
   poolCreateTokens: Token[];
   initialLiquidityTokens: TokenWithAmount[];
@@ -38,17 +22,12 @@ interface UseCreatePoolProps extends BeraJS.BaseFunctionArgs {
   poolSymbol: string;
   poolName: string;
   amplification: number;
-  weightsDuplicationThreshold?: number;
   oracles: Oracle[]; // NOTE: the default state for oracles should be 0x0 address for each token with cache duration of ~100
 }
 interface UseCreatePoolReturn {
   generatedPoolName: string;
   generatedPoolSymbol: string;
-  isDupePool: boolean;
-  dupePool?: SubgraphPoolFragment | null;
   createPoolArgs: any;
-  isLoadingPools: boolean;
-  errorLoadingPools: boolean;
 }
 
 export enum OracleMode {
@@ -276,70 +255,8 @@ export const useCreatePool = ({
   owner,
   amplification,
   oracles,
-  weightsDuplicationThreshold = DEFAULT_WEIGHTS_DUPLICATION_THRESHOLD,
   ...baseArgs
 }: UseCreatePoolProps): UseCreatePoolReturn => {
-  // 1. identify if the pool is a duplicate
-  const {
-    data: dupePool,
-    error: errorLoadingPools,
-    isLoading: isLoadingPools,
-  } = useSWRImmutable<SubgraphPoolFragment | null>(
-    [
-      "useCreatePool__deduped_pool",
-      poolCreateTokens,
-      poolType,
-      normalizedWeights,
-    ],
-    async () => {
-      if (poolCreateTokens.length === 0 || !poolType) {
-        return null;
-      }
-      const bexSubgraphClient = getApolloClient("bex.subgraph", {});
-      try {
-        // NOTE: it should not be possible for native token to be in poolCreateTokens
-        const tokensSorted = wrapNativeTokens(poolCreateTokens)
-          .map((token) => token.address.toLowerCase())
-          .sort((a, b) => (a.toLowerCase() < b.toLowerCase() ? -1 : 1));
-
-        // fetch pools of the same type as the one we are creating
-        const res = await bexSubgraphClient.query<GetDedupedSubgraphPoolsQuery>(
-          {
-            query: GetDedupedSubgraphPools,
-            variables: {
-              tokens: tokensSorted,
-              type: poolType,
-            },
-          },
-        );
-
-        const matchingPools = res.data.pools.filter((pool) => {
-          return pool.tokens?.every((token) =>
-            poolType === PoolType.Weighted
-              ? // in weighted pools, a dupe is if tokens and weights match within tolerance FIXME: we aren't getting weighted pools returned here
-                tokensSorted.includes(token.address) &&
-                Math.abs(
-                  Number(token.weight) -
-                    Number(
-                      formatUnits(
-                        normalizedWeights[tokensSorted.indexOf(token.address)],
-                        18,
-                      ),
-                    ),
-                ) < weightsDuplicationThreshold
-              : // in composable pools a dupe is if the tokens match, handling that the LP token is in the tokens list
-                tokensSorted.includes(token.address) ||
-                token.address === pool.address,
-          );
-        });
-
-        return matchingPools?.at(0) ?? null;
-      } catch {
-        return null;
-      }
-    },
-  );
-
   // Generated names
   const { generatedPoolName, generatedPoolSymbol } = useMemo(() => {
     if (!poolCreateTokens) {
@@ -430,10 +347,6 @@ export const useCreatePool = ({
   return {
     generatedPoolName,
     generatedPoolSymbol,
-    isDupePool: !!dupePool,
-    dupePool,
     createPoolArgs,
-    isLoadingPools,
-    errorLoadingPools,
   };
 };

package/src/hooks/dex/useOnChainPoolData.ts

@@ -2,10 +2,10 @@ import { useMemo } from "react";
 import useSWRImmutable from "swr/immutable";
 import { type Address, formatUnits, isAddress } from "viem";
 
-import type { SubgraphPoolFragment } from "@berachain/graphql/dex/subgraph";
 import { usePublicClient } from "@berachain/wagmi/hooks";
 
 import { getOnChainPool } from "../../actions/dex/getOnChainPool";
+import type { TokenPriceInfo } from "../../types/dex";
 import { useMultipleTokenInformation } from "../tokens/useMultipleTokenInformation";
 import { useTokenCurrentPrices } from "../tokens/useTokenCurrentPrices";
 
@@ -21,7 +21,32 @@ export function useOnChainPoolDataQueryKey(
   return isValid && address ? (["useOnChainPoolData", address] as const) : null;
 }
 
-export interface OnChainPoolFragment extends SubgraphPoolFragment {
+interface OnChainPoolToken {
+  address: Address;
+  name: string;
+  decimals: number;
+  symbol: string;
+  index: number;
+  weight?: string;
+  balance: string;
+  token: {
+    __typename: "Token";
+    token: { address: Address; name: string; decimals: number; symbol: string };
+    latestUSDPrice: TokenPriceInfo | undefined;
+  };
+}
+
+export interface OnChainPoolFragment {
+  id: string;
+  name: string;
+  address: Address;
+  factory: Address;
+  swapFee: string;
+  totalShares: string;
+  totalLiquidity: string;
+  createTime: number;
+  type: string;
+  tokens: OnChainPoolToken[];
   // Reference: https://github.com/balancer/docs-developers/blob/main/references/valuing-balancer-lp-tokens/pools/stablepools.md#getamplificationparameter
   amplificationParameter:
     | {