upshift-sdk 8.20.1

package/lib/services/coingecko/fetcher.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Fetch the latest USD price for a token symbol from CoinGecko's
+ * `/market_chart/range` endpoint, mapped through `COINGECKO_COIN_ID_MAP`.
+ *
+ * @param symbol - Token symbol (case-insensitive). Must be present in
+ *   `COINGECKO_COIN_ID_MAP`.
+ * @param coinGeckoKey - CoinGecko Pro API key passed as `x-cg-pro-api-key`.
+ * @returns The latest price in USD (a number) on success; `null` when the
+ *   response contains an empty or missing `prices` array. `musd` (mezo-usd)
+ *   is a USD-pegged stablecoin and short-circuits to a price of `1`.
+ * @throws {@link AugustValidationError} When `symbol` is not in `COINGECKO_COIN_ID_MAP`.
+ * @throws {@link AugustRateLimitError} On a 429 response from CoinGecko.
+ * @throws {@link AugustServerError} On any other non-2xx response.
+ */
+export declare function fetchTokenPricesFromCoinGecko(symbol: string, coinGeckoKey: string): Promise<number>;

package/lib/services/coingecko/fetcher.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTokenPricesFromCoinGecko = fetchTokenPricesFromCoinGecko;
+const logger_1 = require("../../core/logger");
+const errors_1 = require("../../core/errors");
+const utils_1 = require("./utils");
+/**
+ * Fetch the latest USD price for a token symbol from CoinGecko's
+ * `/market_chart/range` endpoint, mapped through `COINGECKO_COIN_ID_MAP`.
+ *
+ * @param symbol - Token symbol (case-insensitive). Must be present in
+ *   `COINGECKO_COIN_ID_MAP`.
+ * @param coinGeckoKey - CoinGecko Pro API key passed as `x-cg-pro-api-key`.
+ * @returns The latest price in USD (a number) on success; `null` when the
+ *   response contains an empty or missing `prices` array. `musd` (mezo-usd)
+ *   is a USD-pegged stablecoin and short-circuits to a price of `1`.
+ * @throws {@link AugustValidationError} When `symbol` is not in `COINGECKO_COIN_ID_MAP`.
+ * @throws {@link AugustRateLimitError} On a 429 response from CoinGecko.
+ * @throws {@link AugustServerError} On any other non-2xx response.
+ */
+async function fetchTokenPricesFromCoinGecko(symbol, coinGeckoKey) {
+    const coinId = utils_1.COINGECKO_COIN_ID_MAP[symbol.toLowerCase()];
+    if (coinId === 'mezo-usd') {
+        return 1;
+    }
+    if (!coinId) {
+        throw new errors_1.AugustValidationError('INVALID_INPUT', `fetchTokenPricesFromCoinGecko: symbol "${symbol}" is not in COINGECKO_COIN_ID_MAP`, { context: { symbol } });
+    }
+    const sevendDaysInS = 7 * 24 * 60 * 60;
+    const from = Date.now() / 1000 - sevendDaysInS;
+    const url = `https://pro-api.coingecko.com/api/v3/coins/${coinId}/market_chart/range?vs_currency=usd&from=${from}&to=${Math.floor(Date.now() / 1000)}&interval=daily`;
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-cg-pro-api-key': coinGeckoKey,
+            },
+        });
+        if (!response.ok) {
+            if (response.status === 429) {
+                throw new errors_1.AugustRateLimitError(`CoinGecko rate-limited (429): symbol "${symbol}"`, { context: { symbol, coinId, status: response.status } });
+            }
+            throw new errors_1.AugustServerError(response.status, `CoinGecko API error ${response.status} ${response.statusText}: symbol "${symbol}"`, { context: { symbol, coinId } });
+        }
+        const data = (await response.json());
+        // `/market_chart/range` returns `{ prices, market_caps, total_volumes }` —
+        // an object. The previous `data.length` check was always falsy on the
+        // success path and silently collapsed every valid response to `null`.
+        if (data?.prices?.length) {
+            return data.prices[data.prices.length - 1][1];
+        }
+        return null;
+    }
+    catch (error) {
+        logger_1.Logger.log.error('fetchTokenPricesFromCoinGecko', error, {
+            coinId,
+            symbol,
+        });
+        // Re-throw typed SDK errors (AugustRateLimitError, AugustServerError, etc.)
+        // so callers can distinguish rate-limits and server errors from "no data".
+        if (error instanceof errors_1.AugustSDKError)
+            throw error;
+        return null;
+    }
+}
+//# sourceMappingURL=fetcher.js.map

package/lib/services/coingecko/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './fetcher';

package/lib/services/coingecko/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./fetcher"), exports);
+//# sourceMappingURL=index.js.map

package/lib/services/coingecko/utils.d.ts

@@ -0,0 +1 @@
+export declare const COINGECKO_COIN_ID_MAP: Record<string, string>;

package/lib/services/coingecko/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COINGECKO_COIN_ID_MAP = void 0;
+exports.COINGECKO_COIN_ID_MAP = {
+    rseth: 'kelp-dao-restaked-eth',
+    usdc: 'usd-coin',
+    cbbtc: 'coinbase-wrapped-btc',
+    lbtc: 'lombard-staked-btc',
+    wsteth: 'wrapped-steth',
+    susde: 'ethena-staked-usde',
+    ausd: 'agora-dollar',
+    wavax: 'wrapped-avax',
+    cusdo: 'compounding-open-dollar',
+    whype: 'wrapped-hype',
+    usdt: 'binance-bridged-usdt-bnb-smart-chain',
+    usr: 'resolv-usr',
+    tbtc: 'tbtc',
+    ubtc: 'unit-bitcoin',
+    weth: 'weth',
+    teth: 'treehouse-eth',
+    musd: 'mezo-usd',
+    xbtc: 'tbtc',
+};
+//# sourceMappingURL=utils.js.map

package/lib/services/debank/fetcher.d.ts

@@ -0,0 +1,126 @@
+import type { IAddress, IWSMonitorHeaders } from '../../types';
+export interface IDebankStatsObject {
+    asset_usd_value: number;
+    debt_usd_value: number;
+    net_usd_value: number;
+}
+export interface IDebankPoolObject {
+    controller: string;
+    id: string;
+    chain: string;
+    project_id: string;
+    adapter_id?: string | null;
+    time_at?: number | null;
+}
+export interface IDebankProxyDetailObject {
+    project?: Record<string, unknown> | null;
+    proxy_contract_id?: string | null;
+}
+export interface IDebankTokenObject {
+    id: string;
+    chain: string;
+    name: string;
+    symbol: string;
+    display_symbol: unknown;
+    optimized_symbol: string;
+    decimals: number;
+    protocol_id: string;
+    is_core?: boolean | null;
+    price: number;
+    time_at?: number | null;
+    logo_url?: string | null;
+    price_24h_change?: number | null;
+    credit_score?: number | null;
+    is_verified?: boolean | null;
+    is_scam?: boolean | null;
+    is_suspicious?: boolean | null;
+    is_wallet?: boolean | null;
+    amount?: number | null;
+    raw_amount?: number | null;
+}
+export interface IDebankAppTokenObject {
+    id: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logo_url?: string | null;
+    app_id?: string | null;
+    price: number;
+    amount?: number | null;
+    [key: string]: unknown;
+}
+export interface IDebankDetailObject {
+    supply_token_list?: IDebankTokenObject[];
+    reward_token_list?: IDebankTokenObject[];
+    borrow_token_list?: IDebankTokenObject[];
+    health_rate?: number | null;
+}
+export interface IDebankAppPortfolioDetailObject {
+    supply_token_list?: IDebankAppTokenObject[];
+    reward_token_list?: IDebankAppTokenObject[];
+    borrow_token_list?: IDebankAppTokenObject[];
+    description?: string | null;
+}
+export type IDebankPortfolioItemName = 'Yield' | 'Deposit' | 'Staked' | 'Locked' | 'Farming' | 'Leveraged Farming' | 'Lending' | 'Vesting' | 'Rewards' | 'Airdrop' | 'Liquidity Pool' | 'Options Seller' | 'Options Buyer' | 'Insurance' | 'Investment' | 'Governance' | 'Perpetuals' | 'NFT Staked' | 'NFT Liquidity Pool' | 'NFT Lending' | 'NFT Fraction' | 'NFT P2P Borrower' | 'NFT P2P Lender';
+export interface IDebankPortfolioItemObject {
+    stats: IDebankStatsObject;
+    update_at: number;
+    name: IDebankPortfolioItemName;
+    detail_types: string[];
+    detail: IDebankDetailObject;
+    proxy_detail?: IDebankProxyDetailObject | null;
+    position_index?: string | null;
+    pool: IDebankPoolObject;
+}
+export interface IDebankAppPortfolioItemObject {
+    stats: IDebankStatsObject;
+    update_at: number;
+    name: string;
+    detail_types: string[];
+    detail: IDebankAppPortfolioDetailObject;
+    proxy_detail?: IDebankProxyDetailObject | null;
+    position_index?: string | null;
+    [key: string]: unknown;
+}
+export interface IDebankUserProtocol {
+    id: string;
+    chain: string;
+    name: string;
+    logo_url?: string | null;
+    site_url: string;
+    has_supported_portfolio: boolean;
+    portfolio_item_list: IDebankPortfolioItemObject[];
+}
+export interface IDebankAppProtocol {
+    id: string;
+    name: string;
+    logo_url?: string | null;
+    site_url: string;
+    has_supported_portfolio: boolean;
+    portfolio_item_list: IDebankAppPortfolioItemObject[];
+}
+export interface IDebankAccountData {
+    positions: IDebankUserProtocol[];
+    app_positions: IDebankAppProtocol[];
+    tokens: IDebankTokenObject[];
+}
+export interface IDebankAccountDataError {
+    error: string;
+}
+/**
+ * Response type for vault-level DeBank data.
+ * Keys are subaccount addresses, values are either DeBank data or error objects.
+ */
+export type IVaultDebankResponse = Record<string, IDebankAccountData | IDebankAccountDataError>;
+/**
+ * Fetch DeBank data for all subaccounts of a vault in a single request.
+ * @param vaultAddress The vault contract address
+ * @param headers Optional monitoring headers
+ * @returns Dictionary of subaccount addresses to DeBank data, or false on error
+ */
+export declare function fetchVaultDebankResponse(vaultAddress: IAddress, headers?: IWSMonitorHeaders): Promise<IVaultDebankResponse | false>;
+/**
+ * @deprecated Use fetchVaultDebankResponse for vault-level queries.
+ * Fetch DeBank data for a single subaccount address.
+ */
+export declare function fetchDebankResponse(address: IAddress, headers?: IWSMonitorHeaders): Promise<any>;

package/lib/services/debank/fetcher.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVaultDebankResponse = fetchVaultDebankResponse;
+exports.fetchDebankResponse = fetchDebankResponse;
+const core_1 = require("../../core");
+/**
+ * Fetch DeBank data for all subaccounts of a vault in a single request.
+ * @param vaultAddress The vault contract address
+ * @param headers Optional monitoring headers
+ * @returns Dictionary of subaccount addresses to DeBank data, or false on error
+ */
+async function fetchVaultDebankResponse(vaultAddress, headers) {
+    try {
+        const response = await (0, core_1.fetchAugustPublic)(core_1.WEBSERVER_ENDPOINTS.public.tokenizedVault.debank(vaultAddress), { headers: headers });
+        // 200 = success, 207 = partial success (some subaccounts failed)
+        if (response.status === 200 || response.status === 207) {
+            const data = (await response.json());
+            return data;
+        }
+        core_1.Logger.log.error('fetchVaultDebankResponse', new Error(`HTTP ${response.status} ${response.statusText}`), { status: response.status, statusText: response.statusText });
+        return false;
+    }
+    catch (e) {
+        core_1.Logger.log.error('fetchVaultDebankResponse', e);
+        return false;
+    }
+}
+/**
+ * @deprecated Use fetchVaultDebankResponse for vault-level queries.
+ * Fetch DeBank data for a single subaccount address.
+ */
+async function fetchDebankResponse(address, headers) {
+    // filter out hyperevm since debank does not yet support hyperevm
+    const debankResponse = await (0, core_1.fetchAugustWithKey)(undefined, core_1.WEBSERVER_ENDPOINTS.subaccount.debank(address), { override: true, headers: headers });
+    if (debankResponse.status !== 200) {
+        core_1.Logger.log.error('fetchDebankResponse', new Error(`HTTP ${debankResponse.status} ${debankResponse.statusText}`), {
+            status: debankResponse.status,
+            statusText: debankResponse.statusText,
+        });
+        return false;
+    }
+    else if (debankResponse.status === 200) {
+        const debankRes = await debankResponse.json();
+        return debankRes;
+    }
+}
+//# sourceMappingURL=fetcher.js.map

package/lib/services/debank/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fetcher';
+export * from './utils';

package/lib/services/debank/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fetcher"), exports);
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=index.js.map

package/lib/services/debank/utils.d.ts

@@ -0,0 +1,38 @@
+import type { IAddress, IDebankProtocolExposure, IDebankTokenExposure } from '../../types';
+export interface IDebankNormalizedResponse {
+    subaccount: {
+        positions: any[];
+        tokens: any[];
+    };
+}
+export declare function parseVaultLevelDebank(debankRes: any, protocolExposure: IDebankProtocolExposure[], tokenExposure: IDebankTokenExposure[], borrower: IAddress, exposurePerCategory: any, netValue: any): {
+    tokenMap: Record<string, string>;
+    protocolTokenMap: Record<string, string[]>;
+    protocolExposures: any;
+    tokenExposures: any;
+    loansExposure: {
+        exposure: any[];
+        positions: any[];
+    };
+};
+export declare function getVaultExposure(debankResponse: any): {
+    borrowing_exposure: {
+        symbol: string;
+        chain: string;
+        amount: number;
+    }[];
+    supplying_exposure: {
+        symbol: string;
+        chain: string;
+        amount: number;
+    }[];
+    wallet_exposure: {
+        symbol: string;
+        chain: string;
+        amount: number;
+    }[];
+};
+export declare function parseLoanLevelDebank(debankRes: any): {
+    exposure: any[];
+    positions: any[];
+};

package/lib/services/debank/utils.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVaultLevelDebank = parseVaultLevelDebank;
+exports.getVaultExposure = getVaultExposure;
+exports.parseLoanLevelDebank = parseLoanLevelDebank;
+const core_1 = require("../../core");
+const core_2 = require("../../core/helpers/core");
+function addToTokenExposure(token, tokenExposure, exposureType, protocol, exposurePerCategory, netValue, borrower) {
+    const usdAmount = Number(token?.price || 0) * Number(token?.amount);
+    if (exposureType === 'wallet'
+        ? !(0, core_2.filterOutBySize)(usdAmount)
+        : !(0, core_2.filterOutBySize)(usdAmount))
+        return;
+    if (exposureType === 'borrow') {
+        netValue.value -= usdAmount;
+    }
+    else {
+        netValue.value += usdAmount;
+    }
+    const foundTokenExposure = tokenExposure.find((t) => t.symbol === token?.symbol);
+    if (foundTokenExposure &&
+        foundTokenExposure?.exposureType === tokenExposure) {
+        foundTokenExposure.amount += usdAmount;
+    }
+    else {
+        const protoReturnObj = {
+            id: token?.id,
+            chain: token?.chain,
+            name: token?.name,
+            symbol: token?.optimized_symbol || token?.symbol,
+            decimals: token?.decimals,
+            logoUrl: token?.logo_url,
+            amount: usdAmount,
+            protocol: protocol,
+            exposureType: exposureType,
+        };
+        if (exposureType === 'wallet') {
+            exposurePerCategory.wallet.push(protoReturnObj);
+        }
+        else if (exposureType === 'borrow') {
+            exposurePerCategory.borrowing.push(protoReturnObj);
+        }
+        else if (exposureType === 'supply') {
+            exposurePerCategory.supplying.push(protoReturnObj);
+        }
+        tokenExposure.push(protoReturnObj);
+    }
+}
+function parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure, borrower, exposurePerCategory, netValue) {
+    // new mapping to grab vault-level token and protocol exposure per
+    const tokenMap = {};
+    const protocolTokenMap = {};
+    const protocolExposures = debankRes?.subaccount?.positions || [];
+    const appProtocolExposures = debankRes?.subaccount?.app_positions || [];
+    const tokenExposures = debankRes?.subaccount?.tokens || [];
+    protocolExposures.forEach((pos) => {
+        // protocol-level data fetching
+        const protoReturnObj = {
+            id: pos?.id,
+            chain: pos?.chain,
+            protocol: pos?.name,
+            logoUrl: pos?.logo_url,
+            siteUrl: pos?.site_url,
+            assetUsdValue: 0,
+            debtUsdValue: 0,
+            netUsdValue: 0,
+            label: pos?.portfolio_item_list?.[0]?.name,
+            tokenExposure: tokenMap,
+            protocolExposure: protocolTokenMap,
+            address: borrower,
+        };
+        pos?.portfolio_item_list?.forEach((item) => {
+            // initialize protocol exposure
+            protoReturnObj.assetUsdValue += item?.stats?.asset_usd_value || 0;
+            protoReturnObj.debtUsdValue += item?.stats?.debt_usd_value || 0;
+            protoReturnObj.netUsdValue += item?.stats?.net_usd_value || 0;
+        });
+        const foundExistingProtocolExposure = protocolExposure.find((exp) => exp.id === pos.id);
+        if (!foundExistingProtocolExposure &&
+            (0, core_2.filterOutBySize)(protoReturnObj.netUsdValue)) {
+            protocolExposure.push(protoReturnObj);
+        }
+        else if (foundExistingProtocolExposure) {
+            foundExistingProtocolExposure.netUsdValue += protoReturnObj.netUsdValue;
+            foundExistingProtocolExposure.debtUsdValue += protoReturnObj.debtUsdValue;
+            foundExistingProtocolExposure.assetUsdValue +=
+                protoReturnObj.assetUsdValue;
+        }
+        // go through the debank portfolio
+        pos.portfolio_item_list.forEach((item) => {
+            item.detail.supply_token_list.forEach((sup) => {
+                // add protocol id for vault-level "protocol exposure"
+                if (sup?.protocol_id) {
+                    const existingArray = protocolTokenMap[sup.protocol_id] || [];
+                    if (!existingArray.includes(sup.symbol))
+                        existingArray.push(sup.symbol);
+                }
+                // add token to vault "token exposure"
+                addToTokenExposure(sup, tokenExposure, 'supply', pos.id, exposurePerCategory, netValue, borrower);
+                // add token image url to token mapping for display
+                if (sup?.symbol && sup?.logo_url) {
+                    tokenMap[sup.symbol] = sup.logo_url;
+                }
+                tokenMap[sup.supplying_exposure] = 'true';
+            });
+            item.detail.borrow_token_list.forEach((bor) => {
+                // add token to vault "token exposure"
+                addToTokenExposure(bor, tokenExposure, 'borrow', pos.id, exposurePerCategory, netValue, borrower);
+                // add token image url to token mapping for display
+                if (bor?.symbol && bor?.logo_url) {
+                    tokenMap[bor.symbol] = bor.logo_url;
+                }
+                tokenMap[bor.supplying_exposure] = 'true';
+            });
+        });
+    });
+    // Process non-EVM app protocols (e.g. Hyperliquid, Lighter).
+    // These lack chain and protocol_id fields unlike EVM-based positions.
+    appProtocolExposures.forEach((pos) => {
+        const protoReturnObj = {
+            id: pos?.id,
+            chain: null,
+            protocol: pos?.name,
+            logoUrl: pos?.logo_url,
+            siteUrl: pos?.site_url,
+            assetUsdValue: 0,
+            debtUsdValue: 0,
+            netUsdValue: 0,
+            label: pos?.portfolio_item_list?.[0]?.name,
+            tokenExposure: tokenMap,
+            protocolExposure: protocolTokenMap,
+            address: borrower,
+        };
+        pos?.portfolio_item_list?.forEach((item) => {
+            protoReturnObj.assetUsdValue += item?.stats?.asset_usd_value || 0;
+            protoReturnObj.debtUsdValue += item?.stats?.debt_usd_value || 0;
+            protoReturnObj.netUsdValue += item?.stats?.net_usd_value || 0;
+        });
+        const foundExistingProtocolExposure = protocolExposure.find((exp) => exp.id === pos.id);
+        if (!foundExistingProtocolExposure &&
+            (0, core_2.filterOutBySize)(protoReturnObj.netUsdValue)) {
+            protocolExposure.push(protoReturnObj);
+        }
+        else if (foundExistingProtocolExposure) {
+            foundExistingProtocolExposure.netUsdValue += protoReturnObj.netUsdValue;
+            foundExistingProtocolExposure.debtUsdValue += protoReturnObj.debtUsdValue;
+            foundExistingProtocolExposure.assetUsdValue +=
+                protoReturnObj.assetUsdValue;
+        }
+        pos?.portfolio_item_list?.forEach((item) => {
+            (item?.detail?.supply_token_list || []).forEach((sup) => {
+                addToTokenExposure(sup, tokenExposure, 'supply', pos.id, exposurePerCategory, netValue, borrower);
+                if (sup?.symbol && sup?.logo_url) {
+                    tokenMap[sup.symbol] = sup.logo_url;
+                }
+            });
+            (item?.detail?.borrow_token_list || []).forEach((bor) => {
+                addToTokenExposure(bor, tokenExposure, 'borrow', pos.id, exposurePerCategory, netValue, borrower);
+                if (bor?.symbol && bor?.logo_url) {
+                    tokenMap[bor.symbol] = bor.logo_url;
+                }
+            });
+        });
+    });
+    tokenExposures?.forEach((token) => {
+        if (token?.is_wallet) {
+            addToTokenExposure(token, tokenExposure, 'wallet', null, exposurePerCategory, netValue, borrower);
+        }
+    });
+    const loanLevelExposure = parseLoanLevelDebank(debankRes);
+    return {
+        tokenMap,
+        protocolTokenMap,
+        protocolExposures,
+        tokenExposures,
+        loansExposure: loanLevelExposure,
+    };
+}
+function getVaultExposure(debankResponse) {
+    const borrowing_exposure = [];
+    const supplying_exposure = [];
+    const wallet_exposure = [];
+    const positions = debankResponse?.subaccount?.positions ?? [];
+    const tokens = debankResponse?.subaccount?.tokens ?? [];
+    for (const position of positions) {
+        const portfolioItems = position?.portfolio_item_list ?? [];
+        for (const item of portfolioItems) {
+            const borrowTokens = item?.detail?.borrow_token_list ?? [];
+            const supplyTokens = item?.detail?.supply_token_list ?? [];
+            for (const token of tokens) {
+                if (token?.symbol && token?.is_core) {
+                    wallet_exposure.push({
+                        symbol: token.symbol,
+                        chain: token.chain,
+                        amount: token.amount * token.price,
+                    });
+                }
+            }
+            for (const token of borrowTokens) {
+                if (token?.symbol &&
+                    !token.is_suspicious &&
+                    !token.is_scam &&
+                    token?.is_core) {
+                    borrowing_exposure.push({
+                        symbol: token.symbol,
+                        chain: token.chain,
+                        amount: token.amount * token.price,
+                    });
+                }
+            }
+            for (const token of supplyTokens) {
+                if (token?.symbol &&
+                    !token.is_suspicious &&
+                    !token.is_scam &&
+                    token?.is_core) {
+                    // Not sure what isWallet is, but I'm guessing is that this field means that it should be in wallet exposure...
+                    // fwiw I have seen this double counted in supplyTokens AND tokens
+                    if (!token.is_wallet) {
+                        supplying_exposure.push({
+                            symbol: token.symbol,
+                            chain: token.chain,
+                            amount: token.amount * token.price,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return { borrowing_exposure, supplying_exposure, wallet_exposure };
+}
+function parseLoanLevelDebank(debankRes) {
+    let positions = [];
+    let exposure = [];
+    try {
+        // new mapping to grab token and protocol exposure
+        const protocolExposures = [
+            ...(debankRes?.subaccount?.positions || []),
+            ...(debankRes?.subaccount?.app_positions || []),
+        ];
+        // Old mapping to grab token and protocol exposure
+        positions = protocolExposures?.map((p) => ({
+            value: p.logo_url,
+            label: p.name,
+        }));
+        exposure = protocolExposures?.map((p) => p.portfolio_item_list?.map((li) => {
+            const extra = {
+                value: li.pool?.controller,
+                label: li.pool?.adapter_id,
+                usd: li?.stats?.asset_usd_value,
+            };
+            if (li.detail?.supply_token_list?.length) {
+                const returnArr = li.detail?.supply_token_list?.map((t) => ({
+                    value: t?.id,
+                    label: t?.symbol,
+                    usd: t?.amount * t?.price,
+                }));
+                return [...returnArr, extra];
+            }
+            return extra;
+        }));
+        // this is a request where if there is no protocol exposure then show any spots
+        // over 10k in collateral exposure
+        if (protocolExposures.length === 0) {
+            if (debankRes?.subaccount?.tokens) {
+                debankRes.subaccount.tokens.forEach((t) => {
+                    if (t?.amount && t?.price && t.amount * t.price >= 10_000) {
+                        exposure.push({
+                            value: t?.id,
+                            label: t?.symbol,
+                            usd: t?.amount && t?.price ? t.amount * t.price : '',
+                        });
+                    }
+                });
+            }
+        }
+        exposure = exposure?.flat()?.flat();
+        const uniqueExposure = [];
+        exposure?.forEach(function (a) {
+            if (!this[a.value]) {
+                if (a?.value === '0xa1290d69c65a6fe4df752f95823fae25cb99e5a7') {
+                    this[a.value] = { ...a, label: 'rsETH' };
+                }
+                else {
+                    this[a.value] = { ...a };
+                }
+                uniqueExposure.push(this[a.value]);
+            }
+            this[a.value].usd += a.usd;
+        }, Object.create(null));
+        exposure = uniqueExposure;
+    }
+    catch (err) {
+        core_1.Logger.log.error('getPoolLoansData.strategies', err);
+    }
+    return { exposure, positions };
+}
+//# sourceMappingURL=utils.js.map