@continuumdao/ctm-mpc-defi 0.2.0 → 0.2.2

package/dist/protocols/evm/euler-v2/index.d.ts

@@ -1,6 +1,5 @@
-import { d as ProtocolModule } from '../../../types-Ce2qNHai.js';
+import { b as KeyGenSubsetForPermit, e as ProtocolModule } from '../../../types-BfjWdw1j.js';
 import { Address } from 'viem';
-import { K as KeyGenSubsetForPermit } from '../../../keygen-DsINazx8.js';
 
 /** Stay below on-chain max borrow LTV when computing per-round headroom (basis points). */
 declare const EULER_SAME_ASSET_BORROW_PROTOCOL_HEADROOM_BPS = 50n;
@@ -311,7 +310,470 @@ declare function buildEvmMultisignBodyEulerV2BorrowCollateralWithdrawBatch(args:
     messageToSign: string;
 }>;
 
+/** Goldsky GraphQL endpoints from Euler docs (single hosted project). */
+declare const EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID: Readonly<Record<number, string>>;
+type EulerV2AssetModes = {
+    lend: boolean;
+    borrow: boolean;
+    earn: boolean;
+};
+declare function eulerV2GoldskyUrlForChain(chainId: number): string | undefined;
+declare function resolveEulerWrappedNativeToken(chainId: number): Promise<string | null>;
+/** Wrapped gas-token contracts for this chain (Aave + Euler fallbacks); lowercased. Use to fix bad `decimals()` on WETH-class assets. */
+declare function eulerWrappedGasTokenAliasesLower(chainId: number): Promise<ReadonlySet<string>>;
+/** Maps native gas row (`0x000…0`) to wrapped ERC20 for Euler underlying lookups. */
+declare function eulerV2KeyForNodeAssetRow(args: {
+    contractAddress: string;
+    nativeWrapped: string | null;
+}): string | null;
+/** GraphQL POST to the Euler Goldsky subgraph for `chainId`. */
+declare function eulerV2QueryGraphQl<T>(chainId: number, query: string, variables?: Record<string, unknown>): Promise<T>;
+/** Goldsky `trackingActiveAccount.deposits` (encoded like borrows: 0x + 40-hex sub + 40-hex eVault). */
+declare function fetchEulerV2TrackingDepositEntries(args: {
+    chainId: number;
+    mainAddress: Address;
+}): Promise<readonly string[]>;
+type EulerV2ChainAssetCache = {
+    nativeWrapped: string | null;
+    /** Lowercase address → EVK / Earn modes */
+    modesByUnderlying: ReadonlyMap<string, EulerV2AssetModes>;
+};
+declare function fetchEulerV2ChainAssetCache(chainId: number): Promise<EulerV2ChainAssetCache>;
+/** Cached per chain id for the lifetime of the JS realm (same pattern as Aave v4 token cache). */
+declare function ensureEulerV2ChainAssetCache(chainId: number): Promise<EulerV2ChainAssetCache>;
+
+/** Resolved cap when EVK `AmountCap` raw word is 0 (“not set”). */
+declare const EULER_EVAULT_CAP_UNLIMITED_WEI: bigint;
+/** @deprecated Use {@link EULER_EVAULT_CAP_UNLIMITED_WEI}. */
+declare const EULER_EVAULT_SUPPLY_CAP_UNLIMITED_WEI: bigint;
+/**
+ * When `true`, {@link fetchEulerVaultOnChainLendMetricsForVaults} drives Lend/Borrow vault gates and UI fields.
+ * When `false`, the app uses Goldsky subgraph `eulerVaults` caps and `state` (cash / totalBorrows) instead.
+ */
+declare const EULER_V2_PREFER_ON_CHAIN_LEND_METRICS = false;
+/**
+ * EVK `AmountCap`: raw uint16 0 ⇒ “not set” ⇒ unlimited ({@link UINT256_MAX} wei).
+ * See `AmountCapLib.resolve` in euler-vault-kit.
+ */
+declare function resolveEulerAmountCapToWei(rawCap16: number | bigint): bigint;
+/** @deprecated Use {@link resolveEulerAmountCapToWei}. */
+declare const resolveEulerAmountCapToSupplyWei: typeof resolveEulerAmountCapToWei;
+/**
+ * Goldsky `eulerVaults.supplyCap` / `borrowCap` are the **uint16 AmountCap** words from `caps()`,
+ * not resolved underlying wei. Values ≤ `0xffff` must use {@link resolveEulerAmountCapToWei}.
+ * Larger values are treated as already-resolved wei.
+ */
+declare function eulerSubgraphVaultCapToUnderlyingWei(raw: string | undefined | null): bigint;
+type EulerVaultOnChainLendMetrics = {
+    rawSupplyCap16: number;
+    rawBorrowCap16: number;
+    supplyCapWei: bigint;
+    borrowCapWei: bigint;
+    /** Idle underlying in the vault (matches subgraph `state.cash`). */
+    cashWei: bigint;
+    totalBorrowsWei: bigint;
+    /** ERC-4626 total assets; used with {@link supplyCapWei} for max new supply. */
+    totalAssetsWei: bigint;
+};
+/**
+ * Subgraph caps + `state` fields shaped like {@link fetchEulerVaultOnChainLendMetrics}.
+ * Uses `cashWei + totalBorrowsWei` for {@link totalAssetsWei} (same decomposition as the EVK balance sheet the indexer tracks).
+ */
+declare function eulerVaultLendMetricsFromIndexerVaultState(args: {
+    supplyCapRaw: string | null | undefined;
+    borrowCapRaw: string | null | undefined;
+    cashWei: bigint;
+    totalBorrowsWei: bigint;
+    totalAssetsWei: bigint;
+}): EulerVaultOnChainLendMetrics;
+declare function formatEulerResolvedCapOrCashForUi(wei: bigint, decimals: number, symbolSuffix: string): string;
+/** Max new supply (deposit) wei: headroom under resolved supply cap using on-chain `totalAssets`. */
+declare function eulerVaultMaxNewSupplyWei(metrics: EulerVaultOnChainLendMetrics): bigint;
+/** Upper bound for a new borrow: min(cash, borrowCap − totalBorrows) when the borrow cap is finite; `borrowCapWei === 0` disables borrowing. */
+declare function eulerVaultMaxNewBorrowWei(metrics: EulerVaultOnChainLendMetrics): bigint;
+declare function fetchEulerVaultOnChainLendMetrics(args: {
+    rpcUrl: string;
+    chainId: number;
+    evault: Address;
+}): Promise<EulerVaultOnChainLendMetrics>;
+type EulerVaultOnChainLendMetricsResult = {
+    ok: true;
+    data: EulerVaultOnChainLendMetrics;
+} | {
+    ok: false;
+    message: string;
+};
+/** Batch with bounded concurrency (RPC friendly). */
+declare function fetchEulerVaultOnChainLendMetricsForVaults(args: {
+    rpcUrl: string;
+    chainId: number;
+    vaults: readonly {
+        key: string;
+        evault: string;
+    }[];
+}): Promise<ReadonlyMap<string, EulerVaultOnChainLendMetricsResult>>;
+
+/** Annual APY stored as a ray (1e27); supply or borrow from subgraph state. */
+declare function formatEulerRayApyPercent(apyRay: bigint): string;
+/** @deprecated Use {@link formatEulerRayApyPercent}. */
+declare const formatEulerRaySupplyApyPercent: typeof formatEulerRayApyPercent;
+type EulerV2IsolatedLendMarketRow = {
+    vaultId: string;
+    /** Checksummed eVault address for explorers / copy. */
+    evaultAddress: string;
+    marketName: string;
+    decimals: number;
+    cash: bigint;
+    totalBorrows: bigint;
+    supplyApyPercentLabel: string;
+    borrowApyPercentLabel: string;
+    totalSupplyFormatted: string;
+    availableLiquidityFormatted: string;
+    utilizationPercentLabel: string;
+    supplyCapFormatted: string;
+    borrowCapFormatted: string;
+    interestFeeLabel: string;
+    stateIndexedDisplay: string;
+    perspectives: readonly string[];
+    /** Ethereum Vault Connector (EVC) contract for `batch(...)`. */
+    evcAddress: string | null;
+    oracleAddress: string | null;
+    unitOfAccountAddress: string | null;
+    borrowAssetAddressLower: string | null;
+    governonAdminChecksum: string | null;
+    borrowApyRay: bigint;
+    /** Caps, cash, borrows, and total-assets proxy from Goldsky (same shape as on-chain reads). */
+    indexerLendMetrics: EulerVaultOnChainLendMetrics;
+    collateralTokens: readonly {
+        vaultId: string;
+        /** Collateral eVault (checksummed) for on-chain LTV + deposit target. */
+        collateralEvaultAddress: string | null;
+        collateralDecimals: number;
+        collateralAssetAddressLower: string | null;
+        collateralSupplyApyPercentLabel: string;
+        underlyingSymbol: string;
+        underlyingName: string | null;
+        vaultMarketLabel: string;
+    }[];
+};
+/** One borrow-vault × collateral-vault pair (flattened from {@link EulerV2IsolatedLendMarketRow}). */
+type EulerV2BorrowCollateralRow = {
+    pairKey: string;
+    borrowVaultId: string;
+    borrowEvaultAddress: string;
+    borrowMarketName: string;
+    borrowDecimals: number;
+    borrowApyPercentLabel: string;
+    borrowCash: bigint;
+    borrowTotalBorrows: bigint;
+    netApyPercentLabel: string;
+    utilizationPercentLabel: string;
+    availableLiquidityFormatted: string;
+    evcAddress: string | null;
+    oracleAddress: string | null;
+    unitOfAccountAddress: string | null;
+    borrowAssetAddressLower: string | null;
+    governonAdminChecksum: string | null;
+    collateralVaultId: string;
+    collateralEvaultAddress: string | null;
+    collateralSymbol: string;
+    collateralName: string | null;
+    collateralVaultLabel: string;
+    collateralDecimals: number;
+    collateralAssetAddressLower: string | null;
+    collateralSupplyApyPercentLabel: string;
+    borrowIndexerLendMetrics: EulerVaultOnChainLendMetrics;
+};
+declare function flattenEulerV2BorrowCollateralRows(markets: readonly EulerV2IsolatedLendMarketRow[]): EulerV2BorrowCollateralRow[];
+declare function fetchEulerV2IsolatedLendMarketsForRowAsset(args: {
+    chainId: number;
+    /** Assets panel contract address (native row mapped via Euler cache). */
+    contractAddress: string;
+    rpcUrl?: string | undefined;
+    nodeErc20ByAddress?: ReadonlyMap<string, {
+        name: string;
+        symbol: string;
+    }> | undefined;
+    /** Shown asset symbol (helps match Euler app-style “Product SYMBOL” titles). */
+    suppliedAssetSymbol?: string | undefined;
+}): Promise<EulerV2IsolatedLendMarketRow[]>;
+
+/** Curated earn vault addresses from euler-labels (non-deprecated only). */
+declare function fetchEulerLabelsEarnVaultAllowlist(chainId: number): Promise<ReadonlySet<string>>;
+/** Map lowercase address → entity display name from entities.json. */
+declare function fetchEulerLabelsEntityNameByAddress(chainId: number): Promise<ReadonlyMap<string, string>>;
+/** Dialog focus metadata: which Earn vault the deposit batch targets (mirrors lend flow vault meta). */
+type EulerV2EarnFlowVaultMeta = {
+    earnVaultIdLower: string;
+    evaultAddress: string;
+    vaultMarketLabel: string;
+    curatorDisplayName: string;
+};
+type EulerV2EarnStrategyRow = {
+    strategyVaultIdLower: string;
+    strategySymbol: string;
+    supplyApyPercentLabel: string;
+    allocatedAssetsWei: bigint;
+    allocatedHumanLabel: string;
+    /** Share of vault total assets (TVL). */
+    allocationPercentOfTvlLabel: string;
+    allocationCapHumanLabel: string;
+    /** True when cap is unbounded (uint256 max in-contract, or Goldsky subgraph no-cap sentinel). */
+    allocationCapUnlimited: boolean;
+};
+type EulerV2EarnOfferingRow = {
+    vaultIdLower: string;
+    evaultAddress: string;
+    vaultName: string;
+    curatorDisplayName: string;
+    strategyCount: number;
+    supplyApyPercentLabel: string;
+    totalAssetsWei: bigint;
+    totalAssetsHumanLabel: string;
+    availableLiquidityWei: bigint;
+    availableLiquidityHumanLabel: string;
+    performanceFeePercentLabel: string;
+    underlyingDecimals: number;
+    strategies: readonly EulerV2EarnStrategyRow[];
+};
+declare function fetchEulerV2EarnOfferingsForRowAsset(args: {
+    chainId: number;
+    contractAddress: string;
+    underlyingDecimals: number;
+    suppliedAssetSymbol?: string | undefined;
+}): Promise<EulerV2EarnOfferingRow[]>;
+
+/** Row shown on the Euler dialog Positions tab after a deposit request is created from this UI. */
+type EulerV2LendUiPosition = {
+    id: string;
+    chainId: number;
+    vaultId: string;
+    evaultAddress: string;
+    marketName: string;
+    underlyingSymbol: string;
+    amountHuman: string;
+    createdAtMs: number;
+    signRequestId: string | null;
+    /** Chain supply: `convertToAssets(balanceOf)` raw underlying wei (for client-side display if `decimals()` is wrong). */
+    underlyingAssetsWei?: string;
+    /** Chain supply: vault `asset()` lowercased. */
+    underlyingAssetAddressLower?: string;
+    /** Isolated lend vault vs curated Euler Earn vault vs borrow liability. */
+    positionKind?: 'lend' | 'earn' | 'borrow';
+    /** Vault underlying decimals (chain-loaded supply rows) — redeem amount parsing when Assets dialog context is unset. */
+    underlyingAssetDecimals?: number;
+    /** Borrow: EVC account address. Lend/Earn (chain-loaded): vault share holder for `balanceOf` / `maxWithdraw` when not the key address. */
+    subAccountAddress?: string;
+    /** Borrow: liability vault’s configured collateral eVault (LTV pair), if resolved. */
+    collateralEvaultAddress?: string | null;
+    /** Borrow: EVC core from indexer / RPC. */
+    evcAddress?: string | null;
+    /** Borrow: underlying ERC20 of the liability vault. */
+    borrowAssetAddressLower?: string | null;
+    /** Borrow: decimals of the borrowed asset (for repay amount parsing). */
+    borrowAssetDecimals?: number;
+    /** Borrow: snapshot from last load; same as amountHuman when fresh. */
+    borrowDebtHuman?: string;
+    /** Borrow: collateral underlying (eVault asset) for withdraw UX. */
+    collateralAssetAddressLower?: string | null;
+    collateralAssetDecimals?: number;
+    collateralUnderlyingSymbol?: string | null;
+    /** Borrow: liability / collateral value ratio from accountLiquidity (borrowing), as 0–100+ percentage. */
+    currentLtvPercent?: number | null;
+    /** Borrow: max borrow LTV (vault vs collateral) in basis points. */
+    maxLtvBps?: number | null;
+    /** Borrow: liquidation LTV in basis points. */
+    liquidationLtvBps?: number | null;
+};
+type EulerV2LendPositionDraft = Omit<EulerV2LendUiPosition, 'id' | 'createdAtMs' | 'signRequestId'>;
+
+/** Parse `trackingActiveAccount.borrows` entry: 0x + 40-hex subaccount + 40-hex vault. */
+declare function parseEulerTrackingBorrowEntry(entry: string): {
+    subAccount: Address;
+    borrowVault: Address;
+} | null;
+declare function fetchEulerV2TrackingBorrowEntries(args: {
+    chainId: number;
+    mainAddress: Address;
+}): Promise<readonly string[]>;
+/**
+ * Load borrow vault rows for `mainAddress` from the Euler tracking subgraph (`borrows`) plus RPC, and supplement
+ * pairs from `deposits` + on-chain `debtOf` when the indexer lags. Rows with zero debt are kept when the
+ * sub-account still has collateral to withdraw (`maxWithdraw` or vault shares).
+ */
+declare function loadEulerV2BorrowPositionsForOwner(args: {
+    chainId: number;
+    rpcUrl: string;
+    mainAddress: Address;
+}): Promise<EulerV2LendUiPosition[]>;
+/** Live liability vault debt for repay max button / validation. */
+declare function fetchEulerV2BorrowDebtWei(args: {
+    chainId: number;
+    rpcUrl: string;
+    borrowVault: Address;
+    subAccount: Address;
+}): Promise<bigint>;
+
+/**
+ * On-chain lend / earn vault positions: Goldsky `trackingActiveAccount.deposits` + RPC share balances and `convertToAssets`.
+ * Encoding matches borrow tracking entries: `0x` + 40-hex sub-account + 40-hex eVault (see portfolio aggregation).
+ */
+declare function loadEulerV2LendSupplyPositionsForOwner(args: {
+    chainId: number;
+    rpcUrl: string;
+    mainAddress: Address;
+}): Promise<EulerV2LendUiPosition[]>;
+/** Prefer indexer+RPC supply rows over session duplicates (same vault / kind / share holder). */
+declare function mergeEulerV2PositionsTabRows(args: {
+    borrow: readonly EulerV2LendUiPosition[];
+    chainSupply: readonly EulerV2LendUiPosition[];
+    session: readonly EulerV2LendUiPosition[];
+    mainAddressLower: string;
+}): EulerV2LendUiPosition[];
+
+type EulerV2BorrowPairRisk = {
+    maxLtvBps: number;
+    liquidationLtvBps: number;
+};
+/**
+ * Read borrow / liquidation LTV from the liability eVault for a collateral eVault address.
+ */
+declare function fetchEulerV2BorrowPairLtvs(args: {
+    chainId: number;
+    rpcUrl: string;
+    borrowEvault: Address;
+    collateralEvault: Address;
+}): Promise<EulerV2BorrowPairRisk | null>;
+type EulerV2BorrowOracleQuoteSnapshot = {
+    /** UoA out for `10^borrowDecimals` wei of borrow asset (one full token if decimals match). */
+    oneBorrowUnitUoAWei: bigint;
+    /** UoA out for `collateralAmountHuman` of collateral (human → wei using collateralDecimals). */
+    collateralUoAWei: bigint;
+};
+/**
+ * Uses the liability vault’s oracle (same oracle address the vault uses for account health).
+ */
+declare function fetchEulerV2BorrowOracleQuoteSnapshot(args: {
+    chainId: number;
+    rpcUrl: string;
+    oracle: Address;
+    unitOfAccount: Address;
+    borrowAsset: Address;
+    borrowDecimals: number;
+    collateralAsset: Address;
+    collateralDecimals: number;
+    collateralAmountHuman: string;
+}): Promise<EulerV2BorrowOracleQuoteSnapshot | null>;
+/** `borrowHuman ≈ collateralUoA * (ltvPct/100) / oneBorrowUnitUoA` with BigInt rounding down. */
+declare function estimateBorrowHumanFromLtv(args: {
+    collateralUoAWei: bigint;
+    oneBorrowUnitUoAWei: bigint;
+    ltvPercent: number;
+    borrowDecimals: number;
+}): string;
+/**
+ * Max collateral wei such that borrow at `ltvPercent` is ≤ `maxBorrowWei`, capped by wallet.
+ * Uses oracle UoA at **full wallet balance**; assumes `getQuote` scales linearly in collateral amount.
+ */
+declare function maxCollateralWeiCappedByBorrowLiquidity(args: {
+    walletBalWei: bigint;
+    maxBorrowWei: bigint;
+    collateralFullUoAWei: bigint;
+    oneBorrowUnitUoAWei: bigint;
+    ltvPercent: number;
+    borrowDecimals: number;
+}): bigint;
+
+/** Matches `RewardToken` / `ERC20WrapperLocked.LOCK_NORMALIZATION_FACTOR`. */
+declare const REUL_LOCK_DAY_SEC = 86400n;
+/** Matches `RewardToken` linear vesting: 180 days from lock timestamp. */
+declare const REUL_FULL_VEST_SEC: bigint;
+declare const eulerReulUnlockAbi: readonly [{
+    readonly name: "withdrawToByLockTimestamps";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }, {
+        readonly type: "uint256[]";
+        readonly name: "lockTimestamps";
+    }, {
+        readonly type: "bool";
+        readonly name: "allowRemainderLoss";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+type EulerReulVestingTranche = {
+    reulToken: Address;
+    lockTimestampSec: bigint;
+    lockedAmountWei: bigint;
+    /** EUL (underlying) to wallet if unlocking now. */
+    unlockToWalletWei: bigint;
+    /** EUL sent to remainder receiver when unlocking early (forfeiture). */
+    remainderWei: bigint;
+    /** Unix second when this tranche can be fully unlocked with no remainder. */
+    fullVestTimestampSec: bigint;
+    /** Same as `remainderWei === 0n`. */
+    isFullyVested: boolean;
+};
+declare function fetchEulerReulVestingTranches(args: {
+    rpcUrl: string;
+    chainId: number;
+    reulToken: Address;
+    user: Address;
+}): Promise<readonly EulerReulVestingTranche[]>;
+declare function encodeEulerReulWithdrawToByLockTimestampsData(args: {
+    recipient: Address;
+    lockTimestampsSec: readonly bigint[];
+    allowRemainderLoss: boolean;
+}): `0x${string}`;
+/** Gas fallback for `withdrawToByLockTimestamps` (batch). */
+declare const EULER_REUL_UNLOCK_GAS_FALLBACK = 500000n;
+
+/** If `base` already mentions the asset symbol, don’t append it again. */
+declare function eulerLabelsAppendUnderlyingIfDistinct(base: string, underlyingSymbol: string): string;
+/**
+ * Map lowercase eVault address → Euler dApp label base (product name or vault override name).
+ * Returns empty map on HTTP/parse errors (caller keeps subgraph names).
+ */
+declare function fetchEulerLabelsVaultNameMap(chainId: number): Promise<ReadonlyMap<string, string>>;
+declare function eulerLabelsLookupLabelForVault(labelMap: ReadonlyMap<string, string>, evaultAddress: string): string | undefined;
+
+/** CoinGecko `usd` per 1 token, keyed by lowercase contract address. */
+declare function fetchCoingeckoTokenUsdByContract(args: {
+    chainId: number;
+    contractAddressesLower: readonly string[];
+}): Promise<Map<string, number>>;
+type EulerV2PortfolioUsdSnapshot = {
+    totalSuppliedUsd: number | null;
+    totalBorrowedUsd: number | null;
+    netAssetValueUsd: number | null;
+    /** True when any non-zero position lacked a CoinGecko USD price. */
+    partialPricing: boolean;
+    /** No CoinGecko `platform` mapping for this chain — USD not available. */
+    pricingUnavailable: boolean;
+    error: string | null;
+};
+/**
+ * Supplied (deposit vault shares → assets), borrowed (`debtOf`), and NAV in USD via CoinGecko token prices.
+ * Best-effort: chains without CoinGecko platform mapping return `pricingUnavailable`.
+ */
+declare function loadEulerV2PortfolioUsdSnapshot(args: {
+    chainId: number;
+    rpcUrl: string;
+    mainAddress: Address;
+}): Promise<EulerV2PortfolioUsdSnapshot>;
+
+/**
+ * Euler V2: EVM chain IDs that have a Goldsky subgraph endpoint listed in Euler docs.
+ * @see https://docs.euler.finance/developers/data-querying/subgraphs
+ */
+declare function loadEulerV2SupportedChainIds(): Promise<ReadonlySet<number>>;
+
 declare const EULER_V2_PROTOCOL_ID = "euler-v2";
 declare const eulerV2ProtocolModule: ProtocolModule;
 
-export { EULER_SAME_ASSET_BORROW_APPROVAL_BUFFER_BPS, EULER_SAME_ASSET_BORROW_MAX_ROUNDS, EULER_SAME_ASSET_BORROW_PROTOCOL_HEADROOM_BPS, EULER_SAME_ASSET_BORROW_RATIO_STOP_EPS_BPS, EULER_V2_ISOLATED_VAULT_DEPOSIT_FALLBACK_GAS, EULER_V2_PROTOCOL_ID, EULER_V2_VAULT_WITHDRAW_FALLBACK_GAS, buildEvmMultisignBodyEulerV2BorrowCollateralDepositBatch, buildEvmMultisignBodyEulerV2BorrowCollateralWithdrawBatch, buildEvmMultisignBodyEulerV2BorrowRepayBatch, buildEvmMultisignBodyEulerV2IsolatedBorrowBatch, buildEvmMultisignBodyEulerV2IsolatedLendDepositBatch, buildEvmMultisignBodyEulerV2VaultWithdraw, clampEulerUnderlyingDecimalsForEulerUi, eulerBorrowAndCollateralSameAsset, eulerSameAssetApproveAmountWithBuffer, eulerSameAssetTotalCollateralPullWei, eulerV2ProtocolModule, fetchEulerBorrowCollateralMaxWithdrawAssetsWei, fetchEulerLendEarnVaultEffectiveMaxWithdrawWei, fetchEulerVaultAssetDecimals, fetchEulerVaultMaxWithdrawWei, fetchEulerVaultUnderlyingMeta, planSameAssetLeveragedBorrows };
+export { EULER_EVAULT_CAP_UNLIMITED_WEI, EULER_EVAULT_SUPPLY_CAP_UNLIMITED_WEI, EULER_REUL_UNLOCK_GAS_FALLBACK, EULER_SAME_ASSET_BORROW_APPROVAL_BUFFER_BPS, EULER_SAME_ASSET_BORROW_MAX_ROUNDS, EULER_SAME_ASSET_BORROW_PROTOCOL_HEADROOM_BPS, EULER_SAME_ASSET_BORROW_RATIO_STOP_EPS_BPS, EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID, EULER_V2_ISOLATED_VAULT_DEPOSIT_FALLBACK_GAS, EULER_V2_PREFER_ON_CHAIN_LEND_METRICS, EULER_V2_PROTOCOL_ID, EULER_V2_VAULT_WITHDRAW_FALLBACK_GAS, type EulerReulVestingTranche, type EulerV2AssetModes, type EulerV2BorrowCollateralRow, type EulerV2BorrowOracleQuoteSnapshot, type EulerV2BorrowPairRisk, type EulerV2ChainAssetCache, type EulerV2EarnFlowVaultMeta, type EulerV2EarnOfferingRow, type EulerV2EarnStrategyRow, type EulerV2IsolatedLendMarketRow, type EulerV2LendPositionDraft, type EulerV2LendUiPosition, type EulerV2PortfolioUsdSnapshot, type EulerVaultOnChainLendMetrics, type EulerVaultOnChainLendMetricsResult, REUL_FULL_VEST_SEC, REUL_LOCK_DAY_SEC, buildEvmMultisignBodyEulerV2BorrowCollateralDepositBatch, buildEvmMultisignBodyEulerV2BorrowCollateralWithdrawBatch, buildEvmMultisignBodyEulerV2BorrowRepayBatch, buildEvmMultisignBodyEulerV2IsolatedBorrowBatch, buildEvmMultisignBodyEulerV2IsolatedLendDepositBatch, buildEvmMultisignBodyEulerV2VaultWithdraw, clampEulerUnderlyingDecimalsForEulerUi, encodeEulerReulWithdrawToByLockTimestampsData, ensureEulerV2ChainAssetCache, estimateBorrowHumanFromLtv, eulerBorrowAndCollateralSameAsset, eulerLabelsAppendUnderlyingIfDistinct, eulerLabelsLookupLabelForVault, eulerReulUnlockAbi, eulerSameAssetApproveAmountWithBuffer, eulerSameAssetTotalCollateralPullWei, eulerSubgraphVaultCapToUnderlyingWei, eulerV2GoldskyUrlForChain, eulerV2KeyForNodeAssetRow, eulerV2ProtocolModule, eulerV2QueryGraphQl, eulerVaultLendMetricsFromIndexerVaultState, eulerVaultMaxNewBorrowWei, eulerVaultMaxNewSupplyWei, eulerWrappedGasTokenAliasesLower, fetchCoingeckoTokenUsdByContract, fetchEulerBorrowCollateralMaxWithdrawAssetsWei, fetchEulerLabelsEarnVaultAllowlist, fetchEulerLabelsEntityNameByAddress, fetchEulerLabelsVaultNameMap, fetchEulerLendEarnVaultEffectiveMaxWithdrawWei, fetchEulerReulVestingTranches, fetchEulerV2BorrowDebtWei, fetchEulerV2BorrowOracleQuoteSnapshot, fetchEulerV2BorrowPairLtvs, fetchEulerV2ChainAssetCache, fetchEulerV2EarnOfferingsForRowAsset, fetchEulerV2IsolatedLendMarketsForRowAsset, fetchEulerV2TrackingBorrowEntries, fetchEulerV2TrackingDepositEntries, fetchEulerVaultAssetDecimals, fetchEulerVaultMaxWithdrawWei, fetchEulerVaultOnChainLendMetrics, fetchEulerVaultOnChainLendMetricsForVaults, fetchEulerVaultUnderlyingMeta, flattenEulerV2BorrowCollateralRows, formatEulerRayApyPercent, formatEulerRaySupplyApyPercent, formatEulerResolvedCapOrCashForUi, loadEulerV2BorrowPositionsForOwner, loadEulerV2LendSupplyPositionsForOwner, loadEulerV2PortfolioUsdSnapshot, loadEulerV2SupportedChainIds, maxCollateralWeiCappedByBorrowLiquidity, mergeEulerV2PositionsTabRows, parseEulerTrackingBorrowEntry, planSameAssetLeveragedBorrows, resolveEulerAmountCapToSupplyWei, resolveEulerAmountCapToWei, resolveEulerWrappedNativeToken };