@1delta/data-sdk 0.0.40 → 0.0.42

package/dist/lending/aave.d.ts

@@ -0,0 +1,44 @@
+import type { GeneralReservesMap, OracleMap } from './common';
+export type AaveTokensType = {
+    [fork: string]: {
+        [chainId: string]: {
+            [underlying: string]: {
+                aToken: string;
+                sToken: string;
+                vToken: string;
+            };
+        };
+    };
+};
+export type AavePoolsType = {
+    [fork: string]: {
+        [chainId: string]: {
+            pool: string;
+            protocolDataProvider: string;
+        };
+    };
+};
+export type AaveOraclesConfigEntry = {
+    /** Base asset address (if lender uses non-USD base) */
+    baseAsset?: string;
+    /** Fallback BASE_CURRENCY_UNIT as string (converted to bigint at usage) */
+    baseCurrencyUnit?: string;
+    /** Another AAVE fork on the same chain to use as source for base asset USD price */
+    baseAssetSource?: string;
+};
+export type AaveOraclesConfigType = {
+    [lender: string]: {
+        [chainId: string]: AaveOraclesConfigEntry;
+    };
+};
+export type AaveWethGatewayType = {
+    [fork: string]: {
+        [chainId: string]: string;
+    };
+};
+export declare const aaveTokens: () => AaveTokensType;
+export declare const aavePools: () => AavePoolsType;
+export declare const aaveOracles: () => OracleMap;
+export declare const aaveReserves: () => GeneralReservesMap;
+export declare const aaveOraclesConfig: () => AaveOraclesConfigType;
+export declare const aaveWethGateway: () => AaveWethGatewayType;

package/dist/lending/aaveV4.d.ts

@@ -0,0 +1,168 @@
+export type AaveV4ReserveEntry = {
+    reserveId: number;
+    /** Hub-side asset id (scoped to the entry's `hub`) */
+    assetId: number;
+    underlying: string;
+    /**
+     * Per-reserve hub address. Set at reserve init on-chain — different
+     * reserves on the same spoke can have different hubs.
+     */
+    hub: string;
+    /** Optional per-reserve oracle override (defaults to spoke.oracle) */
+    oracle?: string;
+    oracleDecimals?: number;
+};
+export type AaveV4SpokeEntry = {
+    spoke: string;
+    oracle: string;
+    label: string;
+    dynamicConfigKeyMax?: number;
+    /**
+     * UI/grouping hint only (`AAVE_V4_CORE` / `AAVE_V4_PLUS` / `AAVE_V4_PRIME`).
+     * NOT used for routing or lender keying.
+     */
+    baseHubAttribution?: string;
+    reserves: AaveV4ReserveEntry[];
+};
+/** Top-level: chainId → spokeAddrLower → entry */
+export type AaveV4SpokesType = {
+    [chainId: string]: {
+        [spokeAddrLower: string]: AaveV4SpokeEntry;
+    };
+};
+export type AaveV4OracleEntry = {
+    underlying: string;
+    spoke: string;
+    reserveId: number;
+    oracle: string;
+    decimals?: number;
+    source?: string;
+};
+/** Top-level chainId only — no fork dimension. */
+export type AaveV4OraclesType = {
+    [chainId: string]: AaveV4OracleEntry[];
+};
+export type AaveV4PerHubGateways = {
+    nativeGateway?: string;
+    signatureGateway?: string;
+};
+/**
+ * Per-spoke peripherals — extra metadata the lender-metadata repo carries
+ * for spoke-scoped concerns (curated names, position manager registry, …).
+ * Opaque to the data-sdk; surfaced as `any` so consumers (worker-api,
+ * frontend) can read it without dragging the schema into this package.
+ */
+export type AaveV4PerSpokeMeta = {
+    spokeName?: string;
+    spokeId?: string;
+    positionManagers?: Array<{
+        name?: string;
+        address: string;
+        active?: boolean;
+    }>;
+    [k: string]: unknown;
+};
+export type AaveV4ChainPeripherals = {
+    /** Chain-wide fallback gateway addresses */
+    nativeGateway?: string;
+    signatureGateway?: string;
+    /** Per-hub gateway overrides (keyed by lowercase hub address) */
+    perHub?: {
+        [hubAddrLower: string]: AaveV4PerHubGateways;
+    };
+    /** Per-spoke metadata (curated names, position managers, …) */
+    perSpoke?: {
+        [spokeAddrLower: string]: AaveV4PerSpokeMeta;
+    };
+};
+export type AaveV4PeripheralsType = {
+    [chainId: string]: AaveV4ChainPeripherals;
+};
+export declare const aaveV4Spokes: () => AaveV4SpokesType;
+export declare const aaveV4Oracles: () => AaveV4OraclesType;
+export declare const aaveV4Peripherals: () => AaveV4PeripheralsType;
+/**
+ * Look up the spoke entry for a per-spoke V4 lender key (`AAVE_V4_<HEX>`).
+ * Returns `undefined` if no entry exists for that chain/spoke.
+ */
+export declare function getAaveV4SpokeEntry(chainId: string, lenderKey: string): AaveV4SpokeEntry | undefined;
+/**
+ * Native / signature gateway addresses for Aave V4.
+ *
+ * Resolves the spoke from the per-spoke lender key (`AAVE_V4_<HEX>`),
+ * picks the spoke's first reserve to learn its hub, and looks up
+ * `peripherals[chainId].perHub[hub]`. Falls back to the chain-level
+ * default gateways if no per-hub override is set.
+ *
+ * If the caller passes a hub address directly via `hubOverride`, that
+ * takes precedence.
+ */
+export declare function getAaveV4GatewayAddresses(chainId: string, lender: string, hubOverride?: string): {
+    nativeGateway?: string;
+    signatureGateway?: string;
+};
+/**
+ * Look up the per-spoke peripherals metadata for a V4 spoke.
+ *
+ * Sourced from `aave-v4-peripherals.json` `perSpoke[<spokeAddrLower>]`.
+ * Carries curated extras the metadata team maintains alongside the core
+ * registry — most usefully the position-manager registry. Returns
+ * `undefined` if no entry exists for the spoke or if the lender key is
+ * not a per-spoke V4 key.
+ *
+ * Note: the spoke's `label` (curated UI name) lives directly on the
+ * `AaveV4SpokeEntry` from `aaveV4Spokes()` — `perSpoke.spokeName` is a
+ * duplicate of that and is intentionally not surfaced through the public-
+ * data normalizer. Read it through this helper if a consumer needs the
+ * exact value from the peripherals file.
+ */
+export declare function getAaveV4SpokePeripherals(chainId: string, lenderKey: string): AaveV4PerSpokeMeta | undefined;
+/**
+ * Active position-manager addresses for an Aave V4 spoke.
+ *
+ * Returns the lowercase addresses of every entry in
+ * `perSpoke[<spoke>].positionManagers` whose `active` flag is truthy.
+ * Empty array if the spoke has no peripherals entry or no active PMs.
+ *
+ * Use the `byName` lookup form when you need a specific PM (e.g. the
+ * native gateway). Names are matched case-insensitively against the
+ * curated `name` field; partial matches are accepted.
+ */
+export declare function getAaveV4PositionManagers(chainId: string, lenderKey: string): string[];
+/**
+ * Look up a single position-manager address by curated name (partial,
+ * case-insensitive). Returns `undefined` if no match. Useful for
+ * targeting specific PMs like `"native gateway"` or `"signature gateway"`
+ * without hardcoding the addresses.
+ */
+export declare function findAaveV4PositionManager(chainId: string, lenderKey: string, nameQuery: string): string | undefined;
+/**
+ * Synthesize the per-spoke lender key for an Aave V4 spoke.
+ *
+ * Mirrors the Morpho `MORPHO_BLUE_<HEX_NO_0X_UPPER>` convention so the rest
+ * of the codebase can treat each spoke as an isolated market — exactly like a
+ * Morpho Blue market or a Compound V3 Comet — without any V4-specific logic.
+ *
+ * Format: `AAVE_V4_${spokeAddr.slice(2).toUpperCase()}`
+ *
+ * Example:
+ *   spoke = "0x94e7a5dcbe816e498b89ab752661904e2f56c485"
+ *   →     = "AAVE_V4_94E7A5DCBE816E498B89AB752661904E2F56C485"
+ *
+ * The full spoke address is preserved (no truncation) so the key is globally
+ * unique and stable across spoke implementation upgrades (proxy address).
+ * Note: chainId is intentionally NOT in the lender token — the same spoke
+ * address can in principle exist on multiple chains via deterministic
+ * deploys, and chain scoping happens at the marketUid level instead.
+ *
+ * `isAaveV4Type()` continues to work because it uses `startsWith('AAVE_V4')`.
+ */
+export declare function aaveV4SpokeLenderKey(spoke: string): string;
+/**
+ * Inverse of `aaveV4SpokeLenderKey`: given a per-spoke lender key, return
+ * `{ spokeAddrLower }`. Returns `undefined` if the key isn't a per-spoke V4
+ * key (e.g. someone passed the bare prefix `AAVE_V4`).
+ */
+export declare function parseAaveV4SpokeLenderKey(lenderKey: string): {
+    spokeAddrLower: string;
+} | undefined;

package/dist/lending/common.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shapes shared by more than one lender family. Anything used by a single
+ * family belongs in that family's module instead.
+ */
+/** `fork → chainId → reserve/underlying addresses`. Aave, Compound V2 and Compound V3 all use it. */
+export type GeneralReservesMap = {
+    [fork: string]: {
+        [chainId: string]: string[];
+    };
+};
+/** `lender → chainId → oracle address`. Used by the Aave and Compound V2 families. */
+export type OracleMap = {
+    [lender: string]: {
+        [chainId: string]: string;
+    };
+};

package/dist/lending/compoundV2.d.ts

@@ -0,0 +1,38 @@
+import type { GeneralReservesMap, OracleMap } from './common';
+export type CompoundV2PoolsType = {
+    [fork: string]: {
+        [chainId: string]: string;
+    };
+};
+export type CompoundV2TokensType = {
+    [lender: string]: {
+        [chainId: string]: {
+            [address: string]: string;
+        };
+    };
+};
+export type CompoundV2TokenArrayType = {
+    [lender: string]: {
+        [chainId: string]: {
+            cToken: string;
+            underlying: string;
+        }[];
+    };
+};
+export type CompoundV2OraclesConfigEntry = {
+    /** Base asset address (if oracle quotes in a non-USD asset, e.g. native token) */
+    baseAsset?: string;
+    /** Fixed scaling decimals override (defaults to 36 - underlyingDecimals) */
+    scalingDecimals?: number;
+};
+export type CompoundV2OraclesConfigType = {
+    [lender: string]: {
+        [chainId: string]: CompoundV2OraclesConfigEntry;
+    };
+};
+export declare const compoundV2Pools: () => CompoundV2PoolsType;
+export declare const compoundV2Tokens: () => CompoundV2TokensType;
+export declare const compoundV2TokenArray: () => CompoundV2TokenArrayType;
+export declare const compoundV2Reserves: () => GeneralReservesMap;
+export declare const compoundV2Oracles: () => OracleMap;
+export declare const compoundV2OraclesConfig: () => CompoundV2OraclesConfigType;

package/dist/lending/compoundV3.d.ts

@@ -0,0 +1,35 @@
+import type { GeneralReservesMap } from './common';
+export type CompoundV3PoolsType = {
+    [chainId: string]: {
+        [comet: string]: string;
+    };
+};
+export type CompoundV3BulkerType = {
+    [lender: string]: {
+        [chainId: string]: string;
+    };
+};
+export type CompoundV3BaseDataType = {
+    [lender: string]: {
+        [chainId: string]: {
+            baseAsset: string;
+            baseBorrowMin: bigint;
+        };
+    };
+};
+export type CompoundV3OracleEntry = {
+    oracle: string;
+    description: string;
+};
+export type CompoundV3OracleDataMap = {
+    [lender: string]: {
+        [chainId: string]: {
+            [assetAddress: string]: CompoundV3OracleEntry;
+        };
+    };
+};
+export declare const compoundV3Pools: () => CompoundV3PoolsType;
+export declare const compoundV3BaseData: () => CompoundV3BaseDataType;
+export declare const compoundV3Reserves: () => GeneralReservesMap;
+export declare const compoundV3OraclesData: () => CompoundV3OracleDataMap;
+export declare const compoundV3Bulker: () => CompoundV3BulkerType;

package/dist/lending/curvance.d.ts

@@ -0,0 +1,112 @@
+/** The Position Manager variants Curvance deploys, keyed as the app keys them. */
+export type CurvancePositionManagers = {
+    /** Generic non-native ERC-20 legs. The common case (20 of 20 PM'd markets). */
+    simplePositionManager?: string;
+    /** ERC-4626-style collateral that is entered on leverage. */
+    vaultPositionManager?: string;
+    /** Wrapped-native collateral — unwraps / swaps into native before depositing. */
+    nativeVaultPositionManager?: string;
+    /** Pendle principal-token collateral. */
+    pendlePtPositionManager?: string;
+};
+/** Per-chain, protocol-level (evergreen) Curvance addresses. */
+export type CurvanceConfigChain = {
+    /** `CentralRegistry` — `marketManagers()` IS the market discovery, and every
+     *  other singleton hangs off it. The one address the provider bootstraps
+     *  from. */
+    centralRegistry: string;
+    /** `OracleManager` — `getPrice(asset, inUSD, getLower)`. Prices are WAD USD
+     *  and carry an `errorCode` that GATES actions (see the abis header). */
+    oracleManager?: string;
+    /** `ProtocolReader` — `getStaticMarketData()` + `getAllDynamicState(account)`
+     *  return the entire public book and one account's whole portfolio in two
+     *  calls. Optional: the fetchers fall back to a plain multicall over the
+     *  MarketManagers when it is absent. */
+    protocolReader?: string;
+    /** `OptimizerReader` — lens for the LendingOptimizer ("Vaults") surface. */
+    optimizerReader?: string;
+    /**
+     * Native-leverage Position Managers, keyed by MARKET MANAGER address
+     * (lowercase-insensitive on read). A market absent here has no native
+     * leverage — which is a real state, not a gap: 5 of 25 markets on Monad
+     * have none registered.
+     */
+    positionManagers?: {
+        [marketManager: string]: CurvancePositionManagers;
+    };
+    /**
+     * `LendingOptimizer` vaults by symbol. Their shares are collateralisable
+     * through `LendingOptimizerShareCToken`, which is why `hyAUSD` appears as
+     * collateral in two markets.
+     */
+    optimizers?: {
+        [symbol: string]: string;
+    };
+    /**
+     * Swap targets with a registered `externalCalldataChecker`, i.e. the ONLY
+     * routers the native leverage path will accept. Cached here as a hint; the
+     * mapping is DAO-mutable in both directions, so a builder must still probe
+     * `externalCalldataChecker(target)` live and fail closed.
+     */
+    swapTargets?: {
+        [aggregator: string]: string;
+    };
+    /** Optional allowlist of MarketManager addresses. When set, on-chain
+     *  discovery is INTERSECTED with it; absent (the default) publishes every
+     *  listed market. */
+    marketAllowlist?: string[] | null;
+};
+export type CurvanceConfigType = {
+    [lender: string]: {
+        [chainId: string]: CurvanceConfigChain;
+    };
+};
+/**
+ * Built-in Monad deployment seed for Curvance.
+ *
+ * Same arrangement as Resupply: a published `config/curvance.json` still WINS
+ * (see `curvanceConfigFor`), but the provider is live with nothing to publish
+ * because `centralRegistry` is an immutable protocol singleton and the whole
+ * market roster is discovered from it at runtime.
+ *
+ * The `positionManagers` map is the exception and the reason this seed carries
+ * more than one address: PM registration is an un-enumerable mapping, and Monad
+ * public RPCs cap `eth_getLogs` at 100 blocks so `PositionManagerUpdated`
+ * cannot be scanned. Every entry below was verified on-chain 2026-08-07 —
+ * 23/23 answered `isPositionManager == true` on their market AND reported that
+ * same market back from `marketManager()`.
+ *
+ * FIVE live markets have NO Position Manager and therefore no native leverage:
+ * `PT-AUSD-8OCT2026 | AUSD` (the largest market at ~$45M), `PT-earnAUSD | AUSD`,
+ * both `High Yield AUSD Vault` markets, and `aguaUSDCgc | USDC`. Their absence
+ * here is the truth, not a gap to fill in.
+ */
+export declare const CURVANCE_MONAD_CONFIG: CurvanceConfigChain;
+export declare const curvanceConfig: () => CurvanceConfigType;
+/**
+ * Deployment seed for one Curvance lender on a chain. Published metadata wins;
+ * the built-in Monad row is the fallback so the provider works before
+ * `config/curvance.json` exists.
+ */
+export declare const curvanceConfigFor: (lender: string, chainId: string | number) => CurvanceConfigChain | undefined;
+/**
+ * All Curvance lender keys with config on a chain (drives getLendersForChain).
+ * Gated on the CENTRAL REGISTRY — the one address the provider bootstraps from.
+ */
+export declare const curvanceLendersByChain: (chainId: string | number) => string[];
+/**
+ * Position Managers registered for one Curvance market. Returns `undefined`
+ * when the market has none — a real state (5 of 25 on Monad, including the
+ * largest market), and the signal that native leverage is unavailable there.
+ *
+ * Lookup is case-insensitive because market-manager addresses arrive from
+ * `queryTokensListed`/config in mixed checksum forms.
+ */
+export declare const curvancePositionManagersFor: (lender: string, chainId: string | number, marketManager: string) => CurvancePositionManagers | undefined;
+/**
+ * The Position Manager to drive for a market, preferring an explicit `kind` and
+ * otherwise falling back to `simplePositionManager` — which is the right default
+ * because every PM'd market has one, and the vault/native variants exist only as
+ * ALTERNATIVES for legs whose collateral needs an extra wrap step.
+ */
+export declare const curvancePositionManager: (lender: string, chainId: string | number, marketManager: string, kind?: keyof CurvancePositionManagers) => string | undefined;

package/dist/lending/dolomite.d.ts

@@ -0,0 +1,54 @@
+export type DolomiteAggregator = 'odos' | 'paraswap' | 'oogabooga' | 'enso';
+export type DolomiteConfigEntry = {
+    dolomiteMargin: string;
+    expiry?: string;
+    markets?: {
+        [marketId: string]: string;
+    };
+    depositWithdrawalProxy?: string;
+    /**
+     * Modern DepositWithdrawalRouter — required for NATIVE (ETH/BNB) wrap/unwrap
+     * ops. The legacy `depositWithdrawalProxy` rejects direct EOA native sends
+     * ("invalid ETH sender"); ERC-20 deposits/withdrawals still use the proxy.
+     */
+    depositWithdrawalRouter?: string;
+    borrowPositionProxy?: string;
+    genericTraderProxy?: string;
+    aggregatorTraders?: {
+        [K in DolomiteAggregator]?: string;
+    };
+};
+export type DolomiteConfigsType = {
+    [chainId: string]: DolomiteConfigEntry;
+};
+export type DolomiteCategoryParam = {
+    marginRatioOverride: number;
+    liquidationRewardOverride: number;
+};
+export type DolomiteSingleCollateral = {
+    debtMarketIds: string[];
+    marginRatioOverride: number;
+    liquidationRewardOverride: number;
+};
+export type DolomiteEmodeChain = {
+    setter: string;
+    categories: {
+        [category: string]: DolomiteCategoryParam;
+    };
+    marketCategories: {
+        [marketId: string]: string;
+    };
+    riskFeatures: {
+        [marketId: string]: {
+            feature: string;
+            singleCollateral?: DolomiteSingleCollateral[];
+        };
+    };
+};
+export type DolomiteEmodeType = {
+    [chainId: string]: DolomiteEmodeChain;
+};
+export declare const dolomiteConfigs: () => DolomiteConfigsType;
+export declare const dolomiteChains: () => string[];
+export declare const dolomiteEmode: () => DolomiteEmodeType;
+export declare const dolomiteMarketIdByToken: (chainId: string, token: string) => string | undefined;

package/dist/lending/dss.d.ts

@@ -0,0 +1,139 @@
+/** One USDD PSM (1:1 stable swap module; NOT a lending market). */
+export type UsddPsmConfig = {
+    ilk: string;
+    psm: string;
+    /** Approval target for `sellGem` (the PSM's own gem adapter). */
+    gemJoin: string;
+    gem: string;
+    gemSymbol?: string;
+    /** 6 on Ethereum (USDT/USDC), 18 on BNB (BSC-USDT). */
+    gemDecimals: number;
+};
+/** Per-chain dss deployment seed (hand-maintained). */
+export type UsddConfigChain = {
+    /** Core accounting engine — ilk params + urns live here. */
+    vat: string;
+    /** Stability-fee module (`ilks(ilk).duty`, per-second ray). */
+    jug: string;
+    /** Oracle liaison (`ilks(ilk)` → pip + mat). */
+    spot: string;
+    /** Liquidation module (clip, chop, hole per ilk). */
+    dog: string;
+    /** DssCdpManager — CDP ids, urn handles, `cdpAllow` grants. */
+    cdpManager: string;
+    /** DssProxyActions — the atomic one-shot target (via DSProxy.execute). */
+    proxyActions: string;
+    /** ProxyRegistry — `proxies(user)` / `build()` for the DSProxy route. */
+    proxyRegistry: string;
+    /** The debt token. USDD publishes it as `usdd`; Sky (and any future dss
+     *  fork) publishes the neutral `debtToken`. Read via `dssDebtToken`. */
+    usdd?: string;
+    debtToken?: string;
+    /** DaiJoin-equivalent for debt enter/exit — `usddJoin` on USDD,
+     *  `debtJoin` elsewhere. Read via `dssDebtJoin`. */
+    usddJoin?: string;
+    debtJoin?: string;
+    /** Display symbol for the debt asset (`USDD`, `DAI`, …). */
+    debtSymbol?: string;
+    /** Maker's `IlkRegistry` — enumerates ilks and classifies them
+     *  (`info(ilk).class`). Present on Sky; USDD ships no registry. */
+    ilkRegistry?: string;
+    /** Maker chainlog (address book) — Sky only. */
+    chainlog?: string;
+    end?: string;
+    /** Debt decimals (18). */
+    debtDecimals?: number;
+    /** The savings Pot (sDAI-style; savings side lives in margin-fetcher's
+     *  SAVINGS_REGISTRY, carried here for completeness). */
+    pot?: string;
+    susdd?: string;
+    /** 1:1 stable PSMs (swap modules — not lending markets). */
+    psms?: UsddPsmConfig[];
+};
+export type UsddConfigType = {
+    [lender: string]: {
+        [chainId: string]: UsddConfigChain;
+    };
+};
+/** One dss market (= one collateral ilk). */
+export type UsddMarketConfig = {
+    /** Ilk string (e.g. `WBTC-A`) — also the per-market key suffix
+     *  (`USDD_<chainId>_<ILK>`). bytes32-encode via stringToHex(size 32). */
+    ilk: string;
+    /** Collateral adapter — approval target for deposits. */
+    gemJoin: string;
+    collToken: string;
+    collDecimals: number;
+    collSymbol?: string;
+    /** Price feed behind the Spot (OSM/Median). */
+    pip?: string;
+    /** Liquidation ratio, ray (Spot.mat). */
+    mat: string;
+    /** Per-second stability fee, ray (Jug.duty). */
+    duty: string;
+    /** Dutch-auction contract (Dog.clip). */
+    clip?: string;
+    /** Liquidation penalty, wad (Dog.chop; 1e18 = none). */
+    chop?: string;
+    /** Debt ceiling, rad (Vat.ilks.line). */
+    line: string;
+    /** Per-CDP debt floor, rad (Vat.ilks.dust). */
+    dust: string;
+    /** `line == 0` ⇒ the ilk was OFFBOARDED: borrowing is disabled but the
+     *  existing debt is real and repay/withdraw stay open. Set by the Sky
+     *  generator; absent on USDD rows. */
+    offboarded?: boolean;
+    name?: string;
+};
+/** Generated per-chain data: verified ilk list + the cdpi trigger snapshot. */
+export type UsddChainData = {
+    markets: UsddMarketConfig[];
+    /** `cdpManager.cdpi()` at generation time — the USDD.md
+     *  re-evaluation trigger (0 = no CDP ever opened on this chain). */
+    cdpi?: string;
+};
+export type UsddMarketsType = {
+    [lender: string]: {
+        [chainId: string]: UsddChainData;
+    };
+};
+export declare const usddConfig: () => UsddConfigType;
+/** Deployment seed for one USDD lender on a chain (undefined if unloaded). */
+export declare const usddConfigFor: (lender: string, chainId: string | number) => UsddConfigChain | undefined;
+export declare const usddMarkets: () => UsddMarketsType;
+/** Generated chain data (verified ilk list + cdpi snapshot; undefined if unloaded). */
+export declare const usddChainData: (lender: string, chainId: string | number) => UsddChainData | undefined;
+/** Look up one USDD market by its ilk string (the per-market key suffix). */
+export declare const usddMarketByIlk: (lender: string, chainId: string | number, ilk: string) => UsddMarketConfig | undefined;
+/** All USDD lender keys with config on a chain (drives getLendersForChain).
+ *  NB: config presence (`vat`) — not market presence — gates the fan-out, so
+ *  the (empty-roster) provider still runs and reports zero markets rather
+ *  than being invisible; the per-ilk keys only exist once metadata fills. */
+export declare const usddLendersByChain: (chainId: string | number) => string[];
+export declare const skyConfig: () => UsddConfigType;
+export declare const skyConfigFor: (lender: string, chainId: string | number) => UsddConfigChain | undefined;
+export declare const skyMarkets: () => UsddMarketsType;
+export declare const skyChainData: (lender: string, chainId: string | number) => UsddChainData | undefined;
+/** All Sky lender keys with config on a chain (drives getLendersForChain). */
+export declare const skyLendersByChain: (chainId: string | number) => string[];
+/** Deployment seed for ANY dss lender (Sky or a fork such as USDD). */
+export declare const dssConfigFor: (lender: string, chainId: string | number) => UsddConfigChain | undefined;
+/** Generated ilk roster for ANY dss lender. */
+export declare const dssChainData: (lender: string, chainId: string | number) => UsddChainData | undefined;
+/**
+ * One ilk of ANY dss lender, by its ilk string.
+ *
+ * Matches on the SEPARATOR-NORMALISED ilk so that both the on-chain spelling
+ * (`WBTC-A`) and the market-key segment (`WBTC_A`) resolve to the same row.
+ * Market keys are hyphen-free by construction — see margin-fetcher's
+ * `dssLenderKey` — and this is the safety net that keeps a caller passing
+ * either form from silently getting `undefined` (which surfaces as a bogus
+ * "no market roster on this chain" error). Injective because Maker ilks never
+ * contain `_`.
+ */
+export declare const dssMarketByIlk: (lender: string, chainId: string | number, ilk: string) => UsddMarketConfig | undefined;
+/** The debt token of a dss deployment, tolerating both field spellings
+ *  (`usdd` on the published USDD config, `debtToken` on Sky). */
+export declare const dssDebtToken: (cfg?: UsddConfigChain) => string | undefined;
+/** The debt join of a dss deployment (`usddJoin` / `debtJoin`). */
+export declare const dssDebtJoin: (cfg?: UsddConfigChain) => string | undefined;

package/dist/lending/euler.d.ts

@@ -0,0 +1,26 @@
+export type EulerConfigEntry = {
+    evc: string;
+    eVaultFactory: string;
+    protocolConfig: string;
+    vaultLens: string;
+    accountLens: string;
+    oracleLens: string;
+    irmLens: string;
+    utilsLens: string;
+};
+export type EulerConfigsType = {
+    [fork: string]: {
+        [chainId: string]: EulerConfigEntry;
+    };
+};
+export type EulerVaultEntry = {
+    underlying: string;
+    vault: string;
+};
+export type EulerVaultsType = {
+    [fork: string]: {
+        [chainId: string]: EulerVaultEntry[];
+    };
+};
+export declare const eulerConfigs: () => EulerConfigsType;
+export declare const eulerVaults: () => EulerVaultsType;