@1delta/margin-fetcher 0.0.341 → 0.0.400

package/dist/utils/rpcCall.d.ts

@@ -1,65 +0,0 @@
-export interface PreparedCall {
-    address: string;
-    functionName: string;
-    params: any[];
-    abi: any[];
-}
-export interface RawRpcCall {
-    jsonrpc: '2.0';
-    id: number;
-    method: 'eth_call';
-    params: [
-        {
-            to: string;
-            data: string;
-        },
-        string
-    ];
-}
-export interface RawRpcBatch {
-    batchIndex: number;
-    calls: RawRpcCall[];
-    callMetadata: PreparedCall[];
-}
-export declare const multicall3Abi: readonly [{
-    readonly type: "function";
-    readonly name: "aggregate3";
-    readonly stateMutability: "payable";
-    readonly inputs: readonly [{
-        readonly name: "calls";
-        readonly type: "tuple[]";
-        readonly components: readonly [{
-            readonly name: "target";
-            readonly type: "address";
-        }, {
-            readonly name: "allowFailure";
-            readonly type: "bool";
-        }, {
-            readonly name: "callData";
-            readonly type: "bytes";
-        }];
-    }];
-    readonly outputs: readonly [{
-        readonly name: "returnData";
-        readonly type: "tuple[]";
-        readonly components: readonly [{
-            readonly name: "success";
-            readonly type: "bool";
-        }, {
-            readonly name: "returnData";
-            readonly type: "bytes";
-        }];
-    }];
-}];
-export interface MulticallRpcBatch {
-    batchIndex: number;
-    call: RawRpcCall;
-    callMetadata: PreparedCall[];
-}
-export declare function createRawRpcCalls(preparedCalls: PreparedCall[], batchSize?: number, blockTag?: string): RawRpcBatch[];
-/**
- * Creates a single multicall3 aggregate3 RPC call that batches all prepared calls
- * This reduces multiple RPC calls to a single call, avoiding rate limiting
- */
-export declare function createMulticallRpcCall(preparedCalls: PreparedCall[], multicallAddress: string, batchSize?: number, blockTag?: string, allowFailure?: boolean): MulticallRpcBatch[];
-//# sourceMappingURL=rpcCall.d.ts.map

package/dist/utils/rpcCall.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpcCall.d.ts","sourceRoot":"","sources":["../../src/utils/rpcCall.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,GAAG,EAAE,CAAA;IACb,GAAG,EAAE,GAAG,EAAE,CAAA;CACX;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,KAAK,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,UAAU,CAAA;IAClB,MAAM,EAAE;QACN;YACE,EAAE,EAAE,MAAM,CAAA;YACV,IAAI,EAAE,MAAM,CAAA;SACb;QACD,MAAM;KACP,CAAA;CACF;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,YAAY,EAAE,YAAY,EAAE,CAAA;CAC7B;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BhB,CAAA;AAEV,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,UAAU,CAAA;IAChB,YAAY,EAAE,YAAY,EAAE,CAAA;CAC7B;AAED,wBAAgB,iBAAiB,CAC/B,aAAa,EAAE,YAAY,EAAE,EAC7B,SAAS,GAAE,MAAqC,EAChD,QAAQ,GAAE,MAAiB,GAC1B,WAAW,EAAE,CAmCf;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,YAAY,EAAE,EAC7B,gBAAgB,EAAE,MAAM,EACxB,SAAS,GAAE,MAAqC,EAChD,QAAQ,GAAE,MAAiB,EAC3B,YAAY,GAAE,OAAc,GAC3B,iBAAiB,EAAE,CAiDrB"}

package/dist/utils/rpcParse.d.ts

@@ -1,19 +0,0 @@
-import { PreparedCall, RawRpcBatch, MulticallRpcBatch } from './rpcCall';
-export interface RawRpcResponse {
-    jsonrpc: '2.0';
-    id: number;
-    result?: string;
-    error?: {
-        code: number;
-        message: string;
-    };
-}
-export declare function parseRawRpcResponses(responses: RawRpcResponse[], callMetadata: PreparedCall[], allowFailure?: boolean): any[];
-export declare function parseRawRpcBatchResponses(batches: RawRpcBatch[], batchResponses: RawRpcResponse[][], allowFailure?: boolean): any[];
-/**
- * Parses multicall3 aggregate3 responses
- * The response contains an array of {success, returnData} tuples
- * Each returnData needs to be decoded using the original call's ABI
- */
-export declare function parseMulticallRpcResponses(responses: RawRpcResponse[], batches: MulticallRpcBatch[], allowFailure?: boolean): any[];
-//# sourceMappingURL=rpcParse.d.ts.map

package/dist/utils/rpcParse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpcParse.d.ts","sourceRoot":"","sources":["../../src/utils/rpcParse.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAExE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,KAAK,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,MAAM,CAAA;KAChB,CAAA;CACF;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,cAAc,EAAE,EAC3B,YAAY,EAAE,YAAY,EAAE,EAC5B,YAAY,GAAE,OAAc,GAC3B,GAAG,EAAE,CAqCP;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,WAAW,EAAE,EACtB,cAAc,EAAE,cAAc,EAAE,EAAE,EAClC,YAAY,GAAE,OAAc,GAC3B,GAAG,EAAE,CAcP;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,cAAc,EAAE,EAC3B,OAAO,EAAE,iBAAiB,EAAE,EAC5B,YAAY,GAAE,OAAc,GAC3B,GAAG,EAAE,CA0EP"}

package/dist/vaults/aave-earn/abis/index.d.ts

@@ -1,2 +0,0 @@
-export * from './shared';
-//# sourceMappingURL=index.d.ts.map

package/dist/vaults/aave-earn/abis/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vaults/aave-earn/abis/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA"}

package/dist/vaults/aave-earn/abis/shared.d.ts

@@ -1,53 +0,0 @@
-/**
- * On-chain read surface used to enrich the API listing with the fields
- * the Aave GraphQL `Vault` type omits: the share `decimals`,
- * `totalSupply()`, and `convertToAssets(uint256)` (the share price).
- */
-/** Standard ERC-20 `decimals()` + `totalSupply()`. */
-export declare const Erc20MetaAbi: readonly [{
-    readonly name: "decimals";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "uint8";
-    }];
-}, {
-    readonly name: "totalSupply";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-}];
-/** ERC-4626 `convertToAssets(uint256)` — 1 share → X underlying. */
-export declare const Erc4626ConvertAbi: readonly [{
-    readonly name: "convertToAssets";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "shares";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "assets";
-    }];
-}];
-/**
- * ERC-4626 `totalAssets()` — the vault's assets under management in raw
- * underlying units, the canonical TVL. Aave Earn vaults supply into Aave and
- * hold aTokens, so the underlying-token `balanceOf` (and the API's `balance`
- * field) reads ~0; `totalAssets()` is the only correct TVL source.
- */
-export declare const Erc4626TotalAssetsAbi: readonly [{
-    readonly name: "totalAssets";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-}];
-//# sourceMappingURL=shared.d.ts.map

package/dist/vaults/aave-earn/abis/shared.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/vaults/aave-earn/abis/shared.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,sDAAsD;AACtD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;EAef,CAAA;AAEV,oEAAoE;AACpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAQpB,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;EAQxB,CAAA"}

package/dist/vaults/aave-earn/api.d.ts

@@ -1,88 +0,0 @@
-/**
- * Aave public GraphQL API client for Earn ("stable") vaults.
- *
- * Endpoint (no auth):
- *   https://api.v3.aave.com/graphql
- *
- * Unlike Lagoon's API, Aave's `vaults` query has NO "list every vault on
- * a chain" mode — its filter criteria accepts either an explicit set of
- * `{ address, chainId }` pairs OR a set of curator `ownedBy` owner
- * addresses. Discovery therefore rides on our registry: we hand the API
- * the curator owners (and any pinned vault addresses) we know about and
- * it returns their full, live vault set. See {@link getAaveEarnRegistry}.
- *
- * The generic `Vault` type does NOT expose `totalSupply` or the share
- * `decimals`, so this client returns only what the API owns (identity,
- * underlying reserve, APR, `balance` = totalAssets); `fetchPublic`
- * enriches the rest on-chain.
- */
-/** Aave unified GraphQL API (AaveKit), v3. Public — no API key. */
-export declare const AAVE_EARN_API_URL = "https://api.v3.aave.com/graphql";
-/** A `DecimalValue` / `TokenAmount.amount` cell. */
-interface ApiDecimal {
-    raw: string | null;
-    decimals: number | null;
-    value: string | null;
-}
-/** A `TokenAmount`: an `amount` plus its USD valuation. */
-interface ApiTokenAmount {
-    amount: ApiDecimal | null;
-    usd: string | null;
-    usdPerToken: string | null;
-}
-/** A `PercentValue`: `value` is the fraction (0.0425), `formatted` the
- *  percentage (4.25). */
-interface ApiPercent {
-    value: string | null;
-    formatted: string | null;
-}
-/** Shape of a single `vaults.items[]` (Aave `Vault`) entry we consume. */
-export interface AaveApiVault {
-    address: string | null;
-    shareName: string | null;
-    shareSymbol: string | null;
-    owner: string | null;
-    chainId: number | null;
-    vaultApr: ApiPercent | null;
-    fee: ApiPercent | null;
-    /** Reserve `balance` — the underlying the vault holds (= totalAssets). */
-    balance: ApiTokenAmount | null;
-    usedReserve: {
-        underlyingToken: {
-            address: string | null;
-            symbol: string | null;
-            name: string | null;
-            decimals: number | null;
-            imageUrl: string | null;
-        } | null;
-    } | null;
-    /** Present only when the query carried a `user` argument. */
-    userShares: {
-        shares: ApiTokenAmount | null;
-        balance: ApiTokenAmount | null;
-    } | null;
-}
-/** Vault discovery targets for a chain — pulled from the registry. */
-export interface AaveEarnQueryTargets {
-    /** Curator owner addresses to expand via `ownedBy`. */
-    owners: string[];
-    /** Explicitly pinned vault addresses. */
-    vaults: string[];
-}
-/**
- * Fetch every Aave Earn vault on `chainId` matching the given targets.
- *
- * Two query kinds, each with a hard-won constraint:
- *  - **`ownedBy`** (per owner, paginated) — the API's `vaults` filter
- *    returns a curator's vaults across *every* chain, so we filter the
- *    result down to `chainId`. We query one owner at a time because the
- *    batch `criteria.vaults:[…]` form errors server-side.
- *  - **single `vault(by:{address},chainId)`** — for one-off pinned
- *    addresses, one request each (same batch-filter limitation).
- *
- * Merges + de-dups by lowercased address (already chain-scoped). Returns
- * the raw API items; normalization happens in `fetchPublic`.
- */
-export declare function fetchAaveEarnApiVaults(chainId: string, targets: AaveEarnQueryTargets): Promise<AaveApiVault[]>;
-export {};
-//# sourceMappingURL=api.d.ts.map

package/dist/vaults/aave-earn/api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/vaults/aave-earn/api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,oCAAoC,CAAA;AAKlE,oDAAoD;AACpD,UAAU,UAAU;IAClB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAED,2DAA2D;AAC3D,UAAU,cAAc;IACtB,MAAM,EAAE,UAAU,GAAG,IAAI,CAAA;IACzB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAC3B;AAED;yBACyB;AACzB,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAED,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,QAAQ,EAAE,UAAU,GAAG,IAAI,CAAA;IAC3B,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;IACtB,0EAA0E;IAC1E,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9B,WAAW,EAAE;QACX,eAAe,EAAE;YACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;YACtB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;YACrB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;YACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;YACvB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;SACxB,GAAG,IAAI,CAAA;KACT,GAAG,IAAI,CAAA;IACR,6DAA6D;IAC7D,UAAU,EAAE;QACV,MAAM,EAAE,cAAc,GAAG,IAAI,CAAA;QAC7B,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;KAC/B,GAAG,IAAI,CAAA;CACT;AAgCD,sEAAsE;AACtE,MAAM,WAAW,oBAAoB;IACnC,uDAAuD;IACvD,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,yCAAyC;IACzC,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AAsBD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,YAAY,EAAE,CAAC,CAmCzB"}

package/dist/vaults/aave-earn/fetchPublic.d.ts

@@ -1,23 +0,0 @@
-import { MulticallRetryFunction, GenericTokenList } from '../../types';
-import type { AaveEarnVaults } from './types';
-/**
- * One-shot fetcher for all tracked Aave Earn vaults on a chain.
- *
- * Hybrid provenance (mirrors GMX's API + on-chain shape):
- *  1. **API leg** — {@link fetchAaveEarnApiVaults} resolves the tracked
- *     curators/vaults into live `Vault` records (identity, underlying
- *     reserve, `vaultApr`, fee, per-underlying USD price).
- *  2. **On-chain leg** — one multicall over the discovered vaults reads
- *     `totalAssets()` (the canonical TVL — the API `balance` field reads the
- *     vault's ~0 idle underlying, since it supplies into Aave and holds
- *     aTokens), share `decimals()`, `totalSupply()`, and
- *     `convertToAssets(10**shareDecimals)` (the share price).
- *
- * Returns `{}` (no network I/O) when the chain has no tracked curators or
- * pinned vaults. Never throws — the orchestrator logs provider-level
- * failures.
- */
-export declare const fetchAaveEarnVaults: (chainId: string, multicallRetry: MulticallRetryFunction, prices?: {
-    [asset: string]: number;
-}, tokenList?: GenericTokenList) => Promise<AaveEarnVaults>;
-//# sourceMappingURL=fetchPublic.d.ts.map

package/dist/vaults/aave-earn/fetchPublic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetchPublic.d.ts","sourceRoot":"","sources":["../../../src/vaults/aave-earn/fetchPublic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAStE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AA0B7C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,EACf,gBAAgB,sBAAsB,EACtC,SAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,EACxC,YAAW,gBAAqB,KAC/B,OAAO,CAAC,cAAc,CA4JxB,CAAA"}

package/dist/vaults/aave-earn/index.d.ts

@@ -1,5 +0,0 @@
-export { fetchAaveEarnVaults } from './fetchPublic';
-export { AAVE_EARN_API_URL, fetchAaveEarnApiVaults, type AaveApiVault, type AaveEarnQueryTargets, } from './api';
-export type { AaveEarnVault, AaveEarnVaults } from './types';
-export { AAVE_EARN_REGISTRY, getAaveEarnRegistry, hasAaveEarnVaults, resolveAaveEarnCuratorName, type AaveEarnCurator, type AaveEarnChainRegistry, } from './registry';
-//# sourceMappingURL=index.d.ts.map

package/dist/vaults/aave-earn/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vaults/aave-earn/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,oBAAoB,GAC1B,MAAM,OAAO,CAAA;AACd,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC5D,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,0BAA0B,EAC1B,KAAK,eAAe,EACpB,KAAK,qBAAqB,GAC3B,MAAM,YAAY,CAAA"}

package/dist/vaults/aave-earn/registry.d.ts

@@ -1,48 +0,0 @@
-/**
- * Discovery registry for Aave Earn vaults.
- *
- * The Aave GraphQL API cannot enumerate "all vaults on a chain" — it only
- * resolves vaults by explicit `{ address, chainId }` or by curator
- * `ownedBy` owner. So discovery is registry-driven: per chain we pin the
- * curator **owner** addresses whose vaults we surface (the API expands
- * each into that curator's live vault set) plus any one-off vault
- * addresses that don't belong to a tracked curator.
- *
- * Only static discovery metadata lives here — everything per-block
- * (`totalAssets`, `totalSupply`, APR, share price) is fetched live by the
- * API + on-chain enrichment in [`fetchPublic.ts`](./fetchPublic.ts).
- *
- * Extend a chain's `curators` as new Aave Earn curators launch; the
- * fetcher is otherwise chain-agnostic.
- */
-/** A curator whose Aave Earn vaults we surface, queried via `ownedBy`. */
-export interface AaveEarnCurator {
-    /** Vault owner address, lowercased. */
-    owner: string;
-    /** Display name attached to every vault this owner runs. */
-    name?: string;
-}
-/** Per-chain discovery config. */
-export interface AaveEarnChainRegistry {
-    /** Curator owners expanded via the API's `ownedBy` filter. */
-    curators: AaveEarnCurator[];
-    /** One-off pinned vault addresses (no tracked curator), lowercased. */
-    vaults: string[];
-}
-/**
- * Per-chain registry keyed by numeric chain id (string).
- *
- * Seeded from the Aave Earn curator set surfaced by the Aave app / API.
- * `owner` addresses are the vaults' on-chain owner (the curator's
- * multisig/EOA), NOT the vault address.
- */
-export declare const AAVE_EARN_REGISTRY: {
-    [chainId: string]: AaveEarnChainRegistry;
-};
-/** Per-chain discovery config; `{ curators: [], vaults: [] }` when unsupported. */
-export declare const getAaveEarnRegistry: (chainId: string) => AaveEarnChainRegistry;
-/** True when the chain has at least one curator or pinned vault to query. */
-export declare const hasAaveEarnVaults: (chainId: string) => boolean;
-/** Resolve a curator display name from a vault owner address. */
-export declare const resolveAaveEarnCuratorName: (chainId: string, owner: string | null | undefined) => string | undefined;
-//# sourceMappingURL=registry.d.ts.map

package/dist/vaults/aave-earn/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/vaults/aave-earn/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,0EAA0E;AAC1E,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAA;IACb,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,kCAAkC;AAClC,MAAM,WAAW,qBAAqB;IACpC,8DAA8D;IAC9D,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,uEAAuE;IACvE,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AAID;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAAA;CA2BxE,CAAA;AAEH,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,KAAG,qBACR,CAAA;AAE9C,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,KAAG,OAGnD,CAAA;AAED,iEAAiE;AACjE,eAAO,MAAM,0BAA0B,GACrC,SAAS,MAAM,EACf,OAAO,MAAM,GAAG,IAAI,GAAG,SAAS,KAC/B,MAAM,GAAG,SAMX,CAAA"}

package/dist/vaults/aave-earn/types.d.ts

@@ -1,84 +0,0 @@
-import { GenericCurrency } from '../../types/general';
-import type { VaultClassificationFields } from '../classification';
-/**
- * Parsed Aave Earn vault entry.
- *
- * Aave Earn ("stable") vaults are curator-run, standard ERC-4626
- * yield-bearing wrappers over an Aave v3 supply position (the vault
- * supplies its assets into an Aave reserve and skims a performance fee
- * on the yield). Shares are minted 1:1 in decimals with the underlying,
- * so `decimals === assetDecimals` for every entry today — but we still
- * carry `assetDecimals` explicitly to stay uniform with the other
- * providers and survive a future divergent vault.
- *
- * Data provenance is hybrid:
- *  - The Aave public GraphQL API (`https://api.v3.aave.com/graphql`)
- *    supplies discovery, identity, the underlying reserve, `vaultApr`
- *    and `totalAssets` (the reserve `balance`).
- *  - A light on-chain multicall supplies `totalSupply`, the share
- *    `decimals`, and `convertToAssets` (share price) — none of which the
- *    API exposes on the generic `Vault` type.
- *
- * Mirrors the cross-provider load-bearing fields (`address`,
- * `underlying`, `symbol`, `name`, `decimals`, `totalAssets`,
- * `totalSupply`) so `buildVaultLookup` picks it up without branching.
- */
-export interface AaveEarnVault extends VaultClassificationFields {
-    /** Vault (share token) contract address, lowercased. */
-    address: string;
-    /** Underlying ERC-20 address, lowercased (the reserve's `underlyingToken`). */
-    underlying: string;
-    /** Share-token symbol, e.g. `steakUSDC`. */
-    symbol: string;
-    /** Share-token name as returned by the API (`shareName`). */
-    name: string;
-    /** Cross-provider UI label — `${curatorName ?? 'Aave'} ${symbol}`. */
-    displayName: string;
-    /** Curator display name, when resolvable from the vault owner. */
-    curatorName?: string;
-    /** Vault owner (curator) address, lowercased. */
-    owner: string;
-    /** Share-token decimals (equals `assetDecimals` for aToken vaults). */
-    decimals: number;
-    /** Underlying asset decimals. */
-    assetDecimals: number;
-    /** Total underlying held by the vault, raw integer as string
-     *  (asset-decimal scaled). From the reserve `balance` (`totalAssets`). */
-    totalAssets: string;
-    /** Total shares minted, raw integer as string. From on-chain
-     *  `totalSupply()`. */
-    totalSupply: string;
-    /** Raw `convertToAssets(10**shareDecimals)` — 1 share → X underlying,
-     *  asset-decimal scaled. From on-chain `convertToAssets`. Folded into the
-     *  uniform `sharePrice*` fields by `stampVaultClassification`. */
-    convertToAssets: string;
-    /** Raw `convertToShares(10**underlyingDecimals)` — 1 underlying → X shares. */
-    convertToShares: string;
-    /** Supply APR in percent (e.g. `4.25` = 4.25 %). Aave `vaultApr`
-     *  (already net of the vault fee). */
-    supplyRate: number;
-    /** Extra rewards APR in percent. 0 for v1. */
-    rewardsRate: number;
-    /** Sum of `supplyRate + rewardsRate` — what a depositor earns. */
-    depositRate: number;
-    /** Vault performance fee, fraction (e.g. `0.1` = 10 %). From `fee`. */
-    fee: number;
-    /** True — Aave Earn vaults are standard synchronous ERC-4626 vaults. */
-    isErc4626: true;
-    /** Hydrated asset metadata from the provided token list, if any. */
-    asset?: GenericCurrency;
-    /** USD price of one underlying unit (API `usdPerToken`, else prices map). */
-    priceUsd?: number;
-    /** Human-formatted total assets (`totalAssets / 10**assetDecimals`). */
-    totalAssetsFormatted: number;
-    /** Human-formatted total assets in USD. */
-    totalAssetsUsd: number;
-}
-/**
- * Full parsed payload: per-vault-address map (parity with the other
- * providers). Keyed by lowercased vault address.
- */
-export type AaveEarnVaults = {
-    [vaultAddress: string]: AaveEarnVault;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/vaults/aave-earn/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/vaults/aave-earn/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAElE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,aAAc,SAAQ,yBAAyB;IAC9D,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAA;IACf,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAA;IACd,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAA;IACZ,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAA;IACnB,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAA;IAEb,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAA;IAChB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAA;IAErB;8EAC0E;IAC1E,WAAW,EAAE,MAAM,CAAA;IACnB;2BACuB;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB;;sEAEkE;IAClE,eAAe,EAAE,MAAM,CAAA;IACvB,+EAA+E;IAC/E,eAAe,EAAE,MAAM,CAAA;IAEvB;0CACsC;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,8CAA8C;IAC9C,WAAW,EAAE,MAAM,CAAA;IACnB,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;IACnB,uEAAuE;IACvE,GAAG,EAAE,MAAM,CAAA;IAEX,wEAAwE;IACxE,SAAS,EAAE,IAAI,CAAA;IAEf,oEAAoE;IACpE,KAAK,CAAC,EAAE,eAAe,CAAA;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,wEAAwE;IACxE,oBAAoB,EAAE,MAAM,CAAA;IAC5B,2CAA2C;IAC3C,cAAc,EAAE,MAAM,CAAA;CACvB;AAED;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAAA;CACtC,CAAA"}

package/dist/vaults/assetDecimals.d.ts

@@ -1,14 +0,0 @@
-import { MulticallRetryFunction } from '../types';
-/**
- * Read each underlying token's ERC-20 `decimals()`, keyed by lowercased
- * address. Used by the on-chain vault fetchers to format `totalAssets`
- * (denominated in *underlying* units) with the asset's own decimals rather
- * than the vault's share `decimals()` — which, for ERC-4626 vaults with a
- * decimals offset (e.g. MetaMorpho's 18-decimal shares over a 6-decimal
- * asset), would blow the formatted value up/down by 10^offset.
- *
- * `allowFailure` + range-checked so a flaky read on one token can't poison the
- * batch; callers fall back to the share decimals when an entry is missing.
- */
-export declare function fetchAssetDecimals(chainId: string, underlyings: string[], multicallRetry: MulticallRetryFunction): Promise<Map<string, number>>;
-//# sourceMappingURL=assetDecimals.d.ts.map

package/dist/vaults/assetDecimals.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assetDecimals.d.ts","sourceRoot":"","sources":["../../src/vaults/assetDecimals.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAOjD;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,cAAc,EAAE,sBAAsB,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAkB9B"}

package/dist/vaults/classification.d.ts

@@ -1,127 +0,0 @@
-import type { VaultProvider, VaultPublicDataAll } from './fetchVaultsAll';
-import type { GenericCurrency, GenericTokenList } from '../types/general';
-/**
- * Two orthogonal axes for separating savings-like vaults from volatile ones.
- *
- * - `yieldProfile` — NAV behaviour / mechanism. `yield-bearing` = the
- *   share/asset ratio accrues monotonically (LST, staking, savings, lending
- *   supply). `volatile` = a trading / perp / leveraged strategy whose NAV
- *   fluctuates and can draw down (Hyperliquid HLP & friends; any leveraged
- *   strategy vault we explicitly flag).
- * - `denomination` — is the underlying a stablecoin. Independent of
- *   `yieldProfile`: sUSDe is `yield-bearing` + `stable`, wstETH is
- *   `yield-bearing` + `volatile`, an HLP-USDC vault is `volatile` + `stable`.
- */
-export type YieldProfile = 'yield-bearing' | 'volatile';
-export type Denomination = 'stable' | 'volatile';
-export interface VaultClassification {
-    yieldProfile: YieldProfile;
-    denomination: Denomination;
-}
-/**
- * Optional cross-provider fields mixed into every per-provider vault type
- * (and `VaultLookupEntry`) and stamped by `stampVaultClassification`; absent
- * until then.
- *
- * Uniform **share price** — the provider's `convertToAssets`
- * (fluid/savings/lst/morpho/lista/silo/gearbox/euler-earn) or `pricePerShare`
- * (lagoon/yearn), so consumers read one set of fields instead of
- * `convertToAssets ?? pricePerShare`:
- *  - `sharePriceRaw` — raw `convertToAssets(10^shareDecimals)` (asset-scaled
- *    integer string). `'0'` for an empty vault.
- *  - `sharePrice` — that value formatted to underlying units (1 share → X
- *    underlying, a JS number).
- *  - `sharePriceUSD` — `sharePrice * priceUsd` (USD value of 1 share); absent
- *    when no underlying price was supplied/resolved.
- * All absent on hypercore/gmx (no share/asset ratio).
- */
-export interface VaultClassificationFields {
-    yieldProfile?: YieldProfile;
-    denomination?: Denomination;
-    sharePriceRaw?: string;
-    sharePrice?: number;
-    sharePriceUSD?: number;
-    /**
-     * The **share token's own** token-list entry (hydrated from the provided
-     * `tokenList` by `stampVaultClassification`). Unlike `asset` — which is the
-     * *underlying* — this is what the vault/LST *actually is* (e.g. pumpBTC, with
-     * its branded `logoURI` + `assetGroup`), so a UI can show the right icon.
-     * Absent when the caller passed no token list, or the share token isn't in
-     * it.
-     */
-    shareAsset?: GenericCurrency;
-    /**
-     * Resolved branded icon URL for the vault — the single field a UI should
-     * read to render an icon, so consumers don't re-derive the fallback. Set by
-     * `stampVaultClassification` to the first of: the share token's own logo
-     * (`shareAsset.logoURI`, branded — e.g. pumpBTC), the underlying asset's logo
-     * (`asset.logoURI`), or — for GMX GM/GLV tokens that have no `asset` entry —
-     * the long-leg token's logo. Absent when none of those resolve (e.g. no
-     * token list passed, or a HyperCore vault whose underlying isn't hydrated).
-     */
-    logoURI?: string;
-    /**
-     * Redemption model — whether a depositor can withdraw underlying cash
-     * synchronously (standard ERC-4626 up to available liquidity) or must go
-     * through a delay/queue/cooldown.
-     *  - `sync` — morpho/lista/euler-earn/fluid/gearbox/silo/yearn and `instant`
-     *    savings: instant withdraw up to the vault's cash. For these, ~zero
-     *    withdrawable liquidity against non-trivial TVL is a genuine red flag
-     *    (stuck capital — e.g. an allocator parked in an exploited market).
-     *  - `async` — LSTs (unbonding/cooldown/off-chain), cooldown savings (sUSDe),
-     *    and epoch/request vaults (lagoon/upshift). Zero *instant* liquidity is
-     *    expected by design and must NOT be read as a risk.
-     * Absent on hypercore/gmx (USD-denominated, no share redemption model).
-     */
-    redemptionType?: 'sync' | 'async';
-}
-/**
- * Per-vault overrides for strategy vaults that are volatile despite living
- * inside a yield provider (e.g. a leveraged Morpho vault, a Lagoon trading
- * strategy). Keyed by `${chainId}-${lowercasedAddress}`.
- *
- * Seeded from the TradingStrategy dataset
- * (`vault-metadata.json`): vaults flagged `perp_dex_trading_vault` /
- * `proprietary_trading`. As of the May 2026 snapshot, ALL such vaults belong to
- * perp-DEX protocols (Hyperliquid, Lighter, GRVT, …) — none fall inside the
- * EVM providers we index — so this set is intentionally empty today. It is the
- * extension point: add `${chainId}-${address}` rows here when a leveraged /
- * trading strategy vault surfaces inside morpho/euler/silo/lagoon/etc.
- */
-export declare const VOLATILE_VAULT_OVERRIDES: Set<string>;
-/**
- * Curated stablecoin symbol set (normalised uppercase), compiled from the
- * dataset's `stablecoinish`-flagged denominations. Symbol-first so it is
- * chain-agnostic. Combined with a `contains 'USD'` fallback (virtually every
- * USD-substring token is a USD stablecoin) this covers the long tail without
- * per-chain address tables.
- */
-export declare const STABLECOIN_SYMBOLS: Set<string>;
-/** True when a token symbol denotes a (fiat-pegged) stablecoin. */
-export declare const isStablecoinSymbol: (symbol: string | undefined) => boolean;
-export interface ClassifyVaultInput {
-    provider: VaultProvider | 'hypercore' | 'gmx';
-    chainId: string | number;
-    address: string;
-    /** Underlying token symbol, when known (drives `denomination`). */
-    underlyingSymbol?: string;
-}
-/**
- * Classify a vault on both axes. Pure — no I/O. `yieldProfile` is
- * provider-default with a per-vault override; `denomination` is
- * positive-ID by underlying symbol (defaults to `volatile` when unknown).
- */
-export declare const classifyVault: (input: ClassifyVaultInput) => VaultClassification;
-/**
- * Mutate every vault in a `VaultPublicDataAll` payload, setting
- * `yieldProfile` + `denomination` via {@link classifyVault}. Called once in
- * `getVaultPublicDataAll` after the providers resolve and before the lookup
- * is built, so both the per-provider objects and the lookup carry the fields.
- *
- * `denomination` reads the underlying token symbol (`asset.symbol`), falling
- * back to the share symbol when asset metadata wasn't hydrated — most stable
- * vaults embed the stablecoin in their share symbol (`steakUSDC`), and
- * volatile shares rarely contain a stable token name.
- */
-export declare const stampVaultClassification: (data: VaultPublicDataAll, chainId: string | number, tokenList?: GenericTokenList) => void;
-//# sourceMappingURL=classification.d.ts.map

package/dist/vaults/classification.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"classification.d.ts","sourceRoot":"","sources":["../../src/vaults/classification.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAEzE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG,UAAU,CAAA;AACvD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,CAAA;AAEhD,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,YAAY,CAAA;IAC1B,YAAY,EAAE,YAAY,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,yBAAyB;IACxC,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,eAAe,CAAA;IAC5B;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAClC;AAuDD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,aAEnC,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,aAkF7B,CAAA;AAKF,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,GAAG,SAAS,KAAG,OAS/D,CAAA;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,aAAa,GAAG,WAAW,GAAG,KAAK,CAAA;IAC7C,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,kBAAkB,KACxB,mBAUF,CAAA;AAuBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,kBAAkB,EACxB,SAAS,MAAM,GAAG,MAAM,EACxB,YAAW,gBAAqB,KAC/B,IA8EF,CAAA"}

package/dist/vaults/curatorName.d.ts

@@ -1,20 +0,0 @@
-/**
- * Best-effort curator/brand name derived from a vault's display name, for the
- * providers whose data source gives only a curator *address* (no name):
- * Lista (Moolah on-chain) and Euler-Earn (subgraph). Curated-vault names are
- * conventionally `<Curator> [x <Protocol>] <Asset> [Vault|Savings|…]`
- * (e.g. `Gauntlet USDT Vault`, `MEV Capital USDC`, `RockawayX PT Yield`), so
- * the leading run of words up to the asset symbol / a structural word is the
- * curator.
- *
- * Heuristic and intentionally conservative — returns `undefined` rather than a
- * guess when nothing plausible leads the name. Never use it to override a
- * curator name that the provider's API supplies directly (Morpho, Lagoon).
- */
-/**
- * Derive a curator name from a vault display name, or `undefined` when none is
- * plausible. `assetSymbol` (the vault's underlying ticker) is an extra stop
- * token so e.g. `Foo BAR Vault` with asset `BAR` yields `Foo`.
- */
-export declare function curatorNameFromVaultName(name: string | null | undefined, assetSymbol?: string): string | undefined;
-//# sourceMappingURL=curatorName.d.ts.map

package/dist/vaults/curatorName.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"curatorName.d.ts","sourceRoot":"","sources":["../../src/vaults/curatorName.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAkEH;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC/B,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,GAAG,SAAS,CAuBpB"}

package/dist/vaults/displayName.d.ts

@@ -1,19 +0,0 @@
-import { GenericCurrency } from '../types/general';
-/**
- * Compose a clean UI label for a vault: `${curator-or-brand} ${asset.symbol}`.
- *
- * Used by every vault parser to populate the cross-provider `displayName`
- * field. Keeps the synthesis rules in one place so output stays uniform —
- * `Steakhouse USDC`, `Gauntlet WETH`, `cp0x USDC`, `Fluid USDC`, `Silo USDC` —
- * regardless of which provider the entry came from.
- *
- * Fallback ladder:
- *   1. `${curatorName ?? brand} ${asset.symbol}` when the asset symbol
- *      is known (preferred path — both halves human-readable).
- *   2. `fallbackName` when the asset symbol is missing — preserves the
- *      raw on-chain share-token name rather than emitting `Morpho ` with
- *      a trailing space.
- *   3. The brand alone when even `fallbackName` is empty.
- */
-export declare const composeVaultDisplayName: (brand: string, curatorName: string | undefined, asset: GenericCurrency | undefined, fallbackName: string | undefined) => string;
-//# sourceMappingURL=displayName.d.ts.map

package/dist/vaults/displayName.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"displayName.d.ts","sourceRoot":"","sources":["../../src/vaults/displayName.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAElD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,MAAM,EACb,aAAa,MAAM,GAAG,SAAS,EAC/B,OAAO,eAAe,GAAG,SAAS,EAClC,cAAc,MAAM,GAAG,SAAS,KAC/B,MAMF,CAAA"}