@gearbox-protocol/sdk 13.0.0-beta.4 → 13.0.0-beta.5

package/dist/esm/common-utils/utils/creditAccount/calcHealthFactor.js

@@ -0,0 +1,55 @@
+import {
+  PERCENTAGE_FACTOR,
+  PRICE_DECIMALS
+} from "../../../sdk/index.js";
+import { BigIntMath } from "../bigintMath.js";
+import { PriceUtils } from "../priceMath.js";
+const MAX_UINT16 = 65535;
+function calcHealthFactor({
+  assets,
+  quotas,
+  quotasInfo,
+  liquidationThresholds,
+  underlyingToken,
+  debt,
+  prices,
+  tokensList
+}) {
+  if (debt === 0n) return MAX_UINT16;
+  const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
+  const underlyingPrice = prices[underlyingToken] || 0n;
+  const assetMoney = assets.reduce(
+    (acc, { token: tokenAddress, balance: amount }) => {
+      const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
+      const lt = liquidationThresholds[tokenAddress] || 0n;
+      const price = prices[tokenAddress] || 0n;
+      const tokenMoney = PriceUtils.calcTotalPrice(
+        price,
+        amount,
+        tokenDecimals
+      );
+      const tokenLtMoney = tokenMoney * lt / PERCENTAGE_FACTOR;
+      const { isActive = false } = quotasInfo?.[tokenAddress] || {};
+      const quota = quotas[tokenAddress];
+      const quotaBalance = isActive ? quota?.balance || 0n : 0n;
+      const quotaMoney = PriceUtils.calcTotalPrice(
+        underlyingPrice,
+        quotaBalance,
+        underlyingDecimals
+      );
+      const money = quota ? BigIntMath.min(quotaMoney, tokenLtMoney) : tokenLtMoney;
+      return acc + money;
+    },
+    0n
+  );
+  const borrowedMoney = PriceUtils.calcTotalPrice(
+    underlyingPrice || PRICE_DECIMALS,
+    debt,
+    underlyingDecimals
+  );
+  const hfInPercent = borrowedMoney > 0n ? assetMoney * PERCENTAGE_FACTOR / borrowedMoney : 0n;
+  return Number(hfInPercent);
+}
+export {
+  calcHealthFactor
+};

package/dist/esm/common-utils/utils/creditAccount/calcOverallAPY.js

@@ -0,0 +1,60 @@
+import {
+  PERCENTAGE_FACTOR,
+  PRICE_DECIMALS
+} from "../../../sdk/index.js";
+import { PriceUtils } from "../priceMath.js";
+function calcOverallAPY({
+  caAssets,
+  lpAPY,
+  prices,
+  quotas,
+  quotaRates,
+  feeInterest,
+  totalValue,
+  debt,
+  baseRateWithFee,
+  underlyingToken,
+  tokensList
+}) {
+  if (!lpAPY || !totalValue || totalValue <= 0n || !debt || totalValue <= debt)
+    return void 0;
+  const underlyingTokenDecimals = tokensList[underlyingToken]?.decimals || 18;
+  const underlyingPrice = prices[underlyingToken];
+  const assetAPYMoney = caAssets.reduce(
+    (acc, { token: tokenAddress, balance: amount }) => {
+      const apy = lpAPY[tokenAddress] || 0;
+      const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
+      const price = prices[tokenAddress] || 0n;
+      const money = PriceUtils.calcTotalPrice(price, amount, tokenDecimals);
+      const apyMoney = money * BigInt(apy);
+      const { rate: quotaAPY = 0n, isActive = false } = quotaRates?.[tokenAddress] || {};
+      const { balance: quotaBalance = 0n } = quotas[tokenAddress] || {};
+      const quotaAmount = isActive ? quotaBalance : 0n;
+      const quotaMoney = PriceUtils.calcTotalPrice(
+        underlyingPrice || 0n,
+        quotaAmount,
+        underlyingTokenDecimals
+      );
+      const quotaRate = quotaAPY * (BigInt(feeInterest) + PERCENTAGE_FACTOR) / PERCENTAGE_FACTOR;
+      const quotaAPYMoney = quotaMoney * quotaRate;
+      return acc + apyMoney - quotaAPYMoney;
+    },
+    0n
+  );
+  const debtMoney = PriceUtils.calcTotalPrice(
+    underlyingPrice || 0n,
+    debt,
+    underlyingTokenDecimals
+  );
+  const debtAPYMoney = debtMoney * BigInt(baseRateWithFee);
+  const yourAssetsMoney = PriceUtils.calcTotalPrice(
+    underlyingPrice || PRICE_DECIMALS,
+    totalValue - debt,
+    underlyingTokenDecimals
+  );
+  const apyInPercent = (assetAPYMoney - debtAPYMoney) / yourAssetsMoney;
+  return apyInPercent;
+}
+export {
+  calcOverallAPY
+};

package/dist/esm/common-utils/utils/creditAccount/calcQuotaBorrowRate.js

@@ -0,0 +1,18 @@
+function calcQuotaBorrowRate({
+  quotas,
+  quotaRates
+}) {
+  const totalRateBalance = Object.values(quotas).reduce(
+    (acc, { token, balance }) => {
+      const { rate = 0, isActive = false } = quotaRates?.[token] || {};
+      const quotaBalance = isActive ? balance : 0n;
+      const rateBalance = quotaBalance * BigInt(rate);
+      return acc + rateBalance;
+    },
+    0n
+  );
+  return totalRateBalance;
+}
+export {
+  calcQuotaBorrowRate
+};

package/dist/esm/common-utils/utils/creditAccount/calcRelativeBaseBorrowRate.js

@@ -0,0 +1,10 @@
+function calcRelativeBaseBorrowRate({
+  debt,
+  baseRateWithFee,
+  assetAmountInUnderlying
+}) {
+  return debt * BigInt(baseRateWithFee) * assetAmountInUnderlying;
+}
+export {
+  calcRelativeBaseBorrowRate
+};

package/dist/esm/common-utils/utils/creditAccount/debt.js

@@ -0,0 +1,43 @@
+import {
+  PERCENTAGE_FACTOR,
+  PRICE_DECIMALS_POW,
+  WAD_DECIMALS_POW
+} from "../../../sdk/index.js";
+import { BigIntMath } from "../bigintMath.js";
+import { PriceUtils } from "../priceMath.js";
+function calcMaxDebtIncrease(healthFactor, debt, underlyingLT, minHf = Number(PERCENTAGE_FACTOR)) {
+  const result = debt * BigInt(healthFactor - minHf) / BigInt(minHf - underlyingLT);
+  return BigIntMath.max(0n, result);
+}
+function calcMaxLendingDebt({
+  assets,
+  liquidationThresholds,
+  underlyingToken,
+  prices,
+  tokensList,
+  targetHF = PERCENTAGE_FACTOR
+}) {
+  const assetsLTMoney = assets.reduce(
+    (acc, { token: tokenAddress, balance: amount }) => {
+      const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
+      const lt = liquidationThresholds[tokenAddress] || 0n;
+      const price = prices[tokenAddress] || 0n;
+      const tokenMoney = PriceUtils.calcTotalPrice(
+        price,
+        amount,
+        tokenDecimals
+      );
+      const tokenLtMoney = tokenMoney * lt;
+      return acc + tokenLtMoney;
+    },
+    0n
+  );
+  const underlyingPrice = prices[underlyingToken] || 0n;
+  const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
+  const max = underlyingPrice > 0 ? assetsLTMoney * 10n ** BigInt(underlyingDecimals) / underlyingPrice / targetHF / 10n ** BigInt(WAD_DECIMALS_POW - PRICE_DECIMALS_POW) : 0n;
+  return max;
+}
+export {
+  calcMaxDebtIncrease,
+  calcMaxLendingDebt
+};

package/dist/esm/common-utils/utils/creditAccount/getTimeToLiquidation.js

@@ -0,0 +1,18 @@
+import {
+  PERCENTAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  SECONDS_PER_YEAR
+} from "../../../sdk/index.js";
+function getTimeToLiquidation({
+  healthFactor,
+  totalBorrowRate_debt
+}) {
+  if (healthFactor <= PERCENTAGE_FACTOR || totalBorrowRate_debt === 0n)
+    return null;
+  const HF_1 = BigInt(healthFactor) - PERCENTAGE_FACTOR;
+  const brPerYear = BigInt(SECONDS_PER_YEAR) * PERCENTAGE_FACTOR * PERCENTAGE_DECIMALS / totalBorrowRate_debt;
+  return HF_1 * brPerYear * 1000n / PERCENTAGE_FACTOR;
+}
+export {
+  getTimeToLiquidation
+};

package/dist/esm/common-utils/utils/creditAccount/index.js

@@ -0,0 +1,9 @@
+export * from "./calcHealthFactor.js";
+export * from "./calcQuotaBorrowRate.js";
+export * from "./calcQuotaBorrowRate.js";
+export * from "./calcRelativeBaseBorrowRate.js";
+export * from "./debt.js";
+export * from "./getTimeToLiquidation.js";
+export * from "./liquidationPrice.js";
+export * from "./quotaUtils.js";
+export * from "./sort.js";

package/dist/esm/common-utils/utils/creditAccount/liquidationPrice.js

@@ -0,0 +1,23 @@
+import { PERCENTAGE_FACTOR, PRICE_DECIMALS, WAD } from "../../../sdk/index.js";
+function liquidationPrice({
+  liquidationThresholds,
+  debt,
+  underlyingToken,
+  targetToken,
+  assets,
+  tokensList
+}) {
+  const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
+  const { balance: underlyingBalance = 0n } = assets[underlyingToken] || {};
+  const ltUnderlying = liquidationThresholds[underlyingToken] || 0n;
+  const effectiveDebt = (debt - underlyingBalance * ltUnderlying / PERCENTAGE_FACTOR) * WAD / 10n ** BigInt(underlyingDecimals);
+  const targetDecimals = tokensList[targetToken]?.decimals || 18;
+  const { balance: targetBalance = 0n } = assets[targetToken] || {};
+  const effectiveTargetBalance = targetBalance * WAD / 10n ** BigInt(targetDecimals);
+  const lpLT = liquidationThresholds[targetToken] || 0n;
+  if (targetBalance <= 0n || lpLT <= 0n) return 0n;
+  return effectiveDebt * PRICE_DECIMALS * PERCENTAGE_FACTOR / (effectiveTargetBalance * lpLT);
+}
+export {
+  liquidationPrice
+};

package/dist/esm/common-utils/utils/creditAccount/quotaUtils.js

@@ -0,0 +1,125 @@
+import {
+  MIN_INT96,
+  PERCENTAGE_FACTOR
+} from "../../../sdk/index.js";
+import { BigIntMath } from "../bigintMath.js";
+function roundUpQuota(quotaChange) {
+  return quotaChange !== MIN_INT96 ? quotaChange / PERCENTAGE_FACTOR * PERCENTAGE_FACTOR : quotaChange;
+}
+function calcRecommendedQuota({
+  amount,
+  debt,
+  lt,
+  quotaReserve
+}) {
+  const recommendedBaseQuota = BigIntMath.min(
+    debt,
+    amount * lt / PERCENTAGE_FACTOR
+  );
+  const recommendedQuota = recommendedBaseQuota * (PERCENTAGE_FACTOR + quotaReserve) / PERCENTAGE_FACTOR;
+  return roundUpQuota(recommendedQuota);
+}
+function calcDefaultQuota({
+  amount,
+  lt,
+  quotaReserve
+}) {
+  const recommendedBaseQuota = amount * lt / PERCENTAGE_FACTOR;
+  const recommendedQuota = recommendedBaseQuota * (PERCENTAGE_FACTOR + quotaReserve) / PERCENTAGE_FACTOR;
+  return roundUpQuota(recommendedQuota);
+}
+function calcQuotaUpdate(props) {
+  const { quotas, initialQuotas, maxDebt, allowedToSpend, allowedToObtain } = props;
+  const quotaDecrease = Object.keys(allowedToSpend).reduce((acc, token) => {
+    const ch = getSingleQuotaChange(token, 0n, props);
+    if (ch && ch.balance < 0) acc[ch.token] = ch;
+    return acc;
+  }, {});
+  const quotaCap = roundUpQuota(maxDebt * 2n);
+  const quotaBought = Object.values(initialQuotas).reduce(
+    (sum, q) => sum + roundUpQuota(q?.quota || 0n),
+    0n
+  );
+  const quotaReduced = Object.values(quotaDecrease).reduce((sum, q) => {
+    const quotaBalance = q.balance || 0n;
+    const safeBalance = quotaBalance === MIN_INT96 ? BigIntMath.neg(roundUpQuota(initialQuotas[q.token]?.quota || 0n)) : quotaBalance;
+    return sum + safeBalance;
+  }, 0n);
+  const maxQuotaIncrease = roundUpQuota(
+    BigIntMath.max(quotaCap - (quotaBought + quotaReduced), 0n)
+  );
+  const quotaIncrease = Object.keys(allowedToObtain).reduce((acc, token) => {
+    const ch = getSingleQuotaChange(token, maxQuotaIncrease, props);
+    if (ch && ch.balance > 0) acc[ch.token] = ch;
+    return acc;
+  }, {});
+  const quotaChange = {
+    ...quotaDecrease,
+    ...quotaIncrease
+  };
+  const desiredQuota = Object.values(quotas).reduce(
+    (acc, cmQuota) => {
+      const { token, isActive } = cmQuota;
+      const { quota: initialQuota = 0n } = initialQuotas[token] || {};
+      if (!isActive) {
+        acc[token] = {
+          balance: initialQuota,
+          token
+        };
+      } else {
+        const change = quotaChange[token]?.balance || 0n;
+        const quotaAfter = change === MIN_INT96 ? 0n : initialQuota + change;
+        acc[token] = {
+          balance: quotaAfter,
+          token
+        };
+      }
+      return acc;
+    },
+    {}
+  );
+  return {
+    desiredQuota,
+    quotaDecrease: Object.values(quotaDecrease),
+    quotaIncrease: Object.values(quotaIncrease)
+  };
+}
+function getSingleQuotaChange(token, unsafeMaxQuotaIncrease, props) {
+  const { isActive = false } = props.quotas[token] || {};
+  const { quota: unsafeInitialQuota = 0n } = props.initialQuotas[token] || {};
+  if (!isActive) {
+    return void 0;
+  }
+  const assetAfter = props.assetsAfterUpdate[token];
+  const { amountInTarget = 0n } = assetAfter || {};
+  const lt = props.liquidationThresholds[token] || 0n;
+  const maxQuotaIncrease = roundUpQuota(unsafeMaxQuotaIncrease);
+  const initialQuota = roundUpQuota(unsafeInitialQuota);
+  const defaultQuota = props.calcModification?.type === "recommendedQuota" && props.calcModification.debt > 0 ? calcRecommendedQuota({
+    lt,
+    quotaReserve: props.quotaReserve,
+    amount: amountInTarget,
+    debt: props.calcModification.debt
+  }) : calcDefaultQuota({
+    lt,
+    quotaReserve: props.quotaReserve,
+    amount: amountInTarget
+  });
+  const unsafeQuotaChange = roundUpQuota(defaultQuota - initialQuota);
+  const quotaChange = unsafeQuotaChange > 0 ? BigIntMath.min(maxQuotaIncrease, unsafeQuotaChange) : unsafeQuotaChange < 0 && BigIntMath.abs(unsafeQuotaChange) >= initialQuota ? MIN_INT96 : unsafeQuotaChange;
+  const correctIncrease = assetAfter && props.allowedToObtain[token] && quotaChange > 0;
+  const correctDecrease = assetAfter && props.allowedToSpend[token] && quotaChange < 0;
+  if (correctIncrease || correctDecrease) {
+    return {
+      balance: quotaChange,
+      token
+    };
+  }
+  return void 0;
+}
+export {
+  calcDefaultQuota,
+  calcQuotaUpdate,
+  calcRecommendedQuota,
+  roundUpQuota
+};

package/dist/esm/common-utils/utils/creditAccount/sort.js

@@ -0,0 +1,67 @@
+import { PRICE_DECIMALS } from "../../../sdk/index.js";
+import { PriceUtils } from "../priceMath.js";
+function sortBalances(balances, prices, tokens) {
+  return Object.entries(balances).sort(
+    ([addr1, amount1], [addr2, amount2]) => {
+      return assetComparator(
+        {
+          token: addr1,
+          balance: amount1
+        },
+        {
+          token: addr2,
+          balance: amount2
+        },
+        prices,
+        prices,
+        tokens,
+        tokens
+      );
+    }
+  );
+}
+function sortAssets(balances, prices, tokens) {
+  return [...balances].sort(
+    (t1, t2) => assetComparator(t1, t2, prices, prices, tokens, tokens)
+  );
+}
+function assetComparator(t1, t2, prices1, prices2, tokens1, tokens2) {
+  const addr1Lc = t1.token.toLowerCase();
+  const addr2Lc = t2.token.toLowerCase();
+  const token1 = tokens1?.[addr1Lc];
+  const token2 = tokens2?.[addr2Lc];
+  const price1 = prices1?.[addr1Lc] || PRICE_DECIMALS;
+  const price2 = prices2?.[addr2Lc] || PRICE_DECIMALS;
+  const totalPrice1 = PriceUtils.calcTotalPrice(
+    price1,
+    t1.balance,
+    token1?.decimals
+  );
+  const totalPrice2 = PriceUtils.calcTotalPrice(
+    price2,
+    t2.balance,
+    token2?.decimals
+  );
+  if (totalPrice1 === totalPrice2) {
+    return t1.balance === t2.balance ? tokensAbcComparator(token1, token2) : amountAbcComparator(t1.balance, t2.balance);
+  }
+  return amountAbcComparator(totalPrice1, totalPrice2);
+}
+function tokensAbcComparator(t1, t2) {
+  const { symbol: symbol1 = "" } = t1 || {};
+  const { symbol: symbol2 = "" } = t2 || {};
+  const symbol1LC = symbol1.toLowerCase();
+  const symbol2LC = symbol2.toLowerCase();
+  if (symbol1LC === symbol2LC) return 0;
+  return symbol1LC > symbol2LC ? 1 : -1;
+}
+function amountAbcComparator(t1, t2) {
+  return t1 > t2 ? -1 : 1;
+}
+export {
+  amountAbcComparator,
+  assetComparator,
+  sortAssets,
+  sortBalances,
+  tokensAbcComparator
+};

package/dist/esm/{sdk → common-utils}/utils/endpoints.js

@@ -1,4 +1,4 @@
-import { isSupportedNetwork } from "../chain/chains.js";
+import { isSupportedNetwork } from "../../sdk/index.js";
 const CHARTS_BACKEND_ADDRESS = "https://charts-server.fly.dev";
 const STATIC_TOKEN = "https://static.gearbox.finance/tokens/";
 class GearboxBackendApi {
@@ -8,7 +8,7 @@ class GearboxBackendApi {
     const domain = CHARTS_BACKEND_ADDRESS;
     const priceSourceArr = priceSource ? [priceSource] : [];
     const isMain = isSupportedNetwork(chainId);
-    const relativePath = URLApi.getRelativeUrl(
+    const relativePath = getRelativeUrl(
       url,
       isMain ? {
         ...options,
@@ -27,20 +27,15 @@ class GearboxBackendApi {
     const url = `https://dm.gearbox.finance/${network.toLowerCase()}_${root}.json`;
     return url;
   };
-  static apyAllRewards = () => URLApi.getRelativeUrl(
+  static apyAllRewards = () => getRelativeUrl(
     "https://state-cache.gearbox.foundation/apy-server/latest.json"
   );
 }
-class URLApi {
-  constructor() {
-  }
-  static getRelativeUrl = (url, options) => {
-    const { params = {} } = options || {};
-    const paramsString = Object.entries(params).map(([key, value]) => `${key}=${value}`).join("&");
-    return [url, ...paramsString ? [paramsString] : []].join("?");
-  };
-}
+const getRelativeUrl = (url, options) => {
+  const { params = {} } = options || {};
+  const paramsString = Object.entries(params).map(([key, value]) => `${key}=${value}`).join("&");
+  return [url, ...paramsString ? [paramsString] : []].join("?");
+};
 export {
-  GearboxBackendApi,
-  URLApi
+  GearboxBackendApi
 };

package/dist/esm/common-utils/utils/index.js

@@ -0,0 +1,5 @@
+export * from "./assetsMath.js";
+export * from "./bigintMath.js";
+export * from "./creditAccount/index.js";
+export * from "./endpoints.js";
+export * from "./priceMath.js";

package/dist/esm/common-utils/utils/priceMath.js

@@ -0,0 +1,42 @@
+import { PRICE_DECIMALS, WAD } from "../../sdk/index.js";
+class PriceUtils {
+  /**
+   * This class is intentionally non-instantiable.
+   */
+  constructor() {
+  }
+  /**
+   * Calculates normalized total value for a token amount at a given price.
+   *
+   * Formula:
+   * `(amount * WAD * price) / 10^decimals / PRICE_DECIMALS`
+   *
+   * @param price Token unit price in `PRICE_DECIMALS` precision.
+   * @param amount Token amount in raw token units.
+   * @param decimals Token decimals used to normalize `amount` (defaults to `18`).
+   * @returns Total value in WAD-normalized units.
+   */
+  static calcTotalPrice = (price, amount, decimals = 18) => amount * WAD * price / 10n ** BigInt(decimals) / PRICE_DECIMALS;
+  /**
+   * Converts a normalized monetary value into target token amount by price.
+   *
+   * Formula:
+   * `(totalMoney * 10^targetDecimals * PRICE_DECIMALS) / targetPrice / WAD`
+   *
+   * Safety behavior:
+   * - returns `0n` when `targetPrice <= 0n` to avoid invalid division
+   *
+   * @param totalMoney Value to convert, expected in WAD-normalized units.
+   * @param target Conversion target configuration:
+   * - `price`: target token unit price in `PRICE_DECIMALS` precision
+   * - `decimals`: target token decimals (defaults to `18`)
+   * @returns Target token amount in raw token units.
+   */
+  static convertByPrice(totalMoney, { price: targetPrice, decimals: targetDecimals = 18 }) {
+    if (targetPrice <= 0n) return 0n;
+    return totalMoney * 10n ** BigInt(targetDecimals) * PRICE_DECIMALS / targetPrice / WAD;
+  }
+}
+export {
+  PriceUtils
+};

package/dist/esm/sdk/utils/index.js

@@ -1,13 +1,9 @@
 export * from "./AddressMap.js";
 export * from "./AddressSet.js";
 export * from "./abi-decode.js";
-export * from "./assetsMath.js";
-export * from "./bigintMath.js";
 export * from "./bytes32ToString.js";
 export * from "./childLogger.js";
 export * from "./createRawTx.js";
-export * from "./creditAccount.js";
-export * from "./endpoints.js";
 export * from "./etherscan.js";
 export * from "./filterDust.js";
 export * from "./formatter.js";
@@ -15,7 +11,6 @@ export * from "./hex.js";
 export * from "./isDust.js";
 export * from "./json.js";
 export * from "./mappers.js";
-export * from "./priceMath.js";
 export * from "./retry.js";
 export * from "./toAddress.js";
 export * from "./type-utils.js";

package/dist/types/common-utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./utils/index.js";

package/dist/types/common-utils/utils/assetsMath.d.ts

@@ -0,0 +1,114 @@
+import type { Address } from "viem";
+import type { Asset } from "../../sdk/index.js";
+interface TokenDataSlice {
+    symbol: string;
+    decimals: number;
+}
+export interface AssetWithView extends Asset {
+    balanceView: string;
+}
+export interface AssetWithAmountInTarget extends Asset {
+    amountInTarget: bigint;
+}
+interface NextAssetProps<T extends Asset> {
+    allowedTokens: Array<Address>;
+    selectedAssets: Array<T>;
+    balances: Record<Address, bigint>;
+    tokensList: Record<Address, TokenDataSlice>;
+    prices?: Record<Address, bigint>;
+}
+export type WrapResult = [Array<Asset>, bigint, bigint];
+/**
+ * Static helper namespace for asset-list transformations and math.
+ *
+ * The constructor is intentionally private to prevent instantiation.
+ */
+export declare class AssetUtils {
+    private constructor();
+    /**
+     * Selects the next candidate token to add to a selected-asset list.
+     *
+     * Flow:
+     * 1) Removes tokens already present in `selectedAssets`
+     * 2) Builds balances for the remaining allowed tokens
+     * 3) Sorts the balances using `CreditAccountDataUtils.sortBalances`
+     * 4) Returns the highest-priority token address, if any
+     *
+     * Addresses are normalized to lowercase for matching.
+     *
+     * @returns The next token address to select, or `undefined` if no candidates remain.
+     */
+    static nextAsset<T extends Asset>({ allowedTokens, selectedAssets, balances, tokensList, prices, }: NextAssetProps<T>): Address | undefined;
+    /**
+     * Builds a normalized balance record for a specific token subset.
+     *
+     * Missing balances are defaulted to `0n`.
+     *
+     * @param allowedTokens Tokens to include in the output record.
+     * @param externalBalances Source balances keyed by lowercase address.
+     * @returns A record that contains only `allowedTokens`.
+     */
+    private static getBalances;
+    /**
+     * Converts an asset array into a token-address keyed record.
+     *
+     * If duplicate token addresses are present, the last occurrence wins.
+     *
+     * @param a Source asset list.
+     * @returns Record keyed by `asset.token`.
+     */
+    static constructAssetRecord<A extends Asset>(a: Array<A>): Record<`0x${string}`, A>;
+    /**
+     * Creates a reusable wrapper function that merges "unwrapped" and "wrapped"
+     * token balances into the wrapped token representation.
+     *
+     * The returned function:
+     * - converts non-negative unwrapped balance into wrapped units by price
+     * - adds the converted amount to the wrapped token balance
+     * - removes the unwrapped token from the result list
+     * - leaves input untouched when no unwrapped token is present
+     *
+     * @returns A function producing `[assets, convertedUnwrapped, originalWrapped]`.
+     */
+    static memoWrap: (unwrappedAddress: Address, wrappedAddress: Address, prices: Record<Address, bigint>, tokensList: Record<Address, TokenDataSlice>) => (assets: Array<Asset>) => WrapResult;
+    /**
+     * Adds balances from the second asset list into the first list.
+     *
+     * Behavior:
+     * - balances are clamped to non-negative before summation
+     * - tokens found only in `b` are created in the output
+     * - existing asset metadata is preserved from `a` when possible
+     *
+     * @param a Base asset list.
+     * @param b Asset deltas to add.
+     * @returns A merged list containing assets from both inputs.
+     */
+    static sumAssets<A extends Asset, B extends Asset>(a: Array<A>, b: Array<B>): Array<A | B>;
+    /**
+     * Adds balances from the second list to matching assets in the first list.
+     *
+     * Behavior:
+     * - balances are clamped to non-negative before summation
+     * - only assets already present in `a` are returned
+     * - no new token entries are created
+     *
+     * @param a Base asset list.
+     * @param b Asset deltas keyed by token.
+     * @returns Updated version of `a` with adjusted balances.
+     */
+    static addBalances<A extends Asset, B extends Asset>(a: Array<A>, b: Array<B>): Array<A | B>;
+    /**
+     * Subtracts balances in the second list from matching assets in the first list.
+     *
+     * Behavior:
+     * - both operands are clamped to non-negative before subtraction
+     * - output balances are clamped to non-negative after subtraction
+     * - only assets already present in `a` are returned
+     *
+     * @param a Base asset list.
+     * @param b Asset amounts to subtract by token.
+     * @returns Updated `a` list with non-negative post-subtraction balances.
+     */
+    static subAssets<A extends Asset, B extends Asset>(a: Array<A>, b: Array<B>): Array<A>;
+}
+export {};