@1delta/margin-fetcher 0.0.20 → 0.0.22

package/dist/prices/defillama/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/prices/defillama/index.ts"],"names":[],"mappings":"AAkOA,wBAAsB,kBAAkB,iBAwCvC;AAED,wBAAsB,sBAAsB,iBA2C3C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/prices/defillama/index.ts"],"names":[],"mappings":"AA+OA,wBAAsB,kBAAkB,iBAwCvC;AAED,wBAAsB,sBAAsB,iBA4C3C"}

package/dist/prices/defillama/index.js

@@ -103,8 +103,12 @@ const prefixSonic = 'sonic:';
 const WS = '0x039e2fb66102314ce7b64ce5ce3e5183bc94ad38';
 const prefixFantom = 'fantom:';
 const WFTM = '0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83';
+const prefixPolygon = 'polygon:';
+const TRUMATIC = '0xf33687811f3ad0cd6b48dd4b39f9f977bd7165a2';
 const prefixHyperEVM = 'hyperliquid:';
 const WYPE = '0x5555555555555555555555555555555555555555';
+const WSTHYPE = '0x94e8396e0869c9f2200760af0621afd240e1cf38';
+const kHYPE = '0xfd739d4e423301ce9385c1fb8850539d657c296d';
 // const prefixKaia = 'kaia:'
 // const WKAIA = '0x19aac5f612f524b754ca7e7c41cbfa2e981a4432'
 const datasAvalanche = [WAVAX, SAVAX].map((d) => prefixAvalanche + d).join(',');
@@ -116,8 +120,11 @@ const datasBase = [AERO].map((d) => prefixBase + d).join(',');
 const datasCore = [WCORE].map((d) => prefixCore + d).join(',');
 const datasMetis = [WMETIS].map((d) => prefixMetis + d).join(',');
 const datasFantom = [WFTM].map((d) => prefixFantom + d).join(',');
+const datasPolygon = [TRUMATIC].map((d) => prefixPolygon + d).join(',');
 const datasSonic = [WS].map((d) => prefixSonic + d).join(',');
-const datasHyperEvm = [WYPE].map((d) => prefixHyperEVM + d).join(',');
+const datasHyperEvm = [WYPE, WSTHYPE, kHYPE]
+    .map((d) => prefixHyperEVM + d)
+    .join(',');
 // const datasKaia = [WKAIA].map((d) => prefixKaia + d).join(',')
 const URL = `https://coins.llama.fi/prices/current/${[
     datasEthereum,
@@ -131,6 +138,7 @@ const URL = `https://coins.llama.fi/prices/current/${[
     datasHyperEvm,
     //   datasKaia,
     datasSonic, //
+    datasPolygon,
 ].join(',')}?searchWidth=4h`;
 const URL_HIST = (ref) => `https://coins.llama.fi/prices/historical/${ref}/${[
     datasEthereum,
@@ -143,6 +151,7 @@ const URL_HIST = (ref) => `https://coins.llama.fi/prices/historical/${ref}/${[
     datasFantom,
     // datasKaia,
     datasHyperEvm,
+    datasPolygon,
     datasSonic, //
 ].join(',')}?searchWidth=4h`;
 const SYMBOL_MAP = {
@@ -206,6 +215,9 @@ const SYMBOL_MAP = {
     wkaia: 'KAIA',
     savax: 'SAVAX',
     whype: 'WHYPE',
+    khype: 'Kinetiq Staked HYPE::kHYPE',
+    wsthype: 'Staked HYPE Shares::WSTHYPE',
+    trumatic: 'TRUMATIC',
 };
 export async function fetchDefillamaData() {
     try {
@@ -270,6 +282,7 @@ export async function fetchDefillamaHistData() {
         histPrices['SUBTC'] = histPrices['WBTC'];
         histPrices['IBTC'] = histPrices['WBTC'];
         histPrices['ENZOBTC'] = histPrices['WBTC'];
+        histPrices['CBBTC'] = histPrices['WBTC'];
         histPrices['PUMPBTC'] = histPrices['WBTC'];
         return histPrices;
     }

package/dist/prices/main-prices/addresses/chainlink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chainlink.d.ts","sourceRoot":"","sources":["../../../../src/prices/main-prices/addresses/chainlink.ts"],"names":[],"mappings":"AAGA,oBAAY,0BAA0B;IACpC,OAAO,IAAI;IACX,MAAM,IAAA;IACN,SAAS,IAAA;IACT,SAAS,IAAA;IACT,eAAe,IAAA;CAChB;AAGD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmJ5B,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MAAM,EAGxD,CAAA;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAukBpC,CAAA"}
+{"version":3,"file":"chainlink.d.ts","sourceRoot":"","sources":["../../../../src/prices/main-prices/addresses/chainlink.ts"],"names":[],"mappings":"AAEA,oBAAY,0BAA0B;IACpC,OAAO,IAAI;IACX,MAAM,IAAA;IACN,SAAS,IAAA;IACT,SAAS,IAAA;IACT,eAAe,IAAA;CAChB;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4K5B,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MAAM,EAKxD,CAAA;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAukBpC,CAAA"}

package/dist/prices/main-prices/addresses/chainlink.js

@@ -1,4 +1,4 @@
-import { Chain } from "@1delta/asset-registry";
+import { Chain } from '@1delta/asset-registry';
 export var ChainlinkAggregatorIndexes;
 (function (ChainlinkAggregatorIndexes) {
     ChainlinkAggregatorIndexes[ChainlinkAggregatorIndexes["roundId"] = 0] = "roundId";
@@ -9,7 +9,7 @@ export var ChainlinkAggregatorIndexes;
 })(ChainlinkAggregatorIndexes || (ChainlinkAggregatorIndexes = {}));
 export const chainlinkOracles = {
     'MIMATIC-USD': {
-        [Chain.POLYGON_MAINNET]: '0xd8d483d813547cfb624b8dc33a00f2fcbcd2d428'
+        [Chain.POLYGON_MAINNET]: '0xd8d483d813547cfb624b8dc33a00f2fcbcd2d428',
     },
     'BTC-ETH': {
         [Chain.POLYGON_MAINNET]: '0x19b0F0833C78c0848109E3842D34d2fDF2cA69BA',
@@ -30,34 +30,34 @@ export const chainlinkOracles = {
         [Chain.BNB_SMART_CHAIN_MAINNET]: '0x9ef1B8c0E4F7dc8bF5719Ea496883DC6401d5b2e',
     },
     'BNB-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x0567F2323251f0Aab15c8dFb1967E4e8A7D42aeE'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x0567F2323251f0Aab15c8dFb1967E4e8A7D42aeE',
     },
     'CAKE-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xB6064eD41d4f67e353768aA239cA86f4F73665a1'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xB6064eD41d4f67e353768aA239cA86f4F73665a1',
     },
     'DOGE-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x3AB0A0d137D4F946fBB19eecc6e92E64660231C8'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x3AB0A0d137D4F946fBB19eecc6e92E64660231C8',
     },
     'DOT-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xC333eb0086309a16aa7c8308DfD32c8BBA0a2592'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xC333eb0086309a16aa7c8308DfD32c8BBA0a2592',
     },
     'BUSD-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xcBb98864Ef56E9042e7d2efef76141f15731B82f'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xcBb98864Ef56E9042e7d2efef76141f15731B82f',
     },
     'BETH-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x2A3796273d47c4eD363b361D3AEFb7F7E2A13782'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x2A3796273d47c4eD363b361D3AEFb7F7E2A13782',
     },
     'FIL-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xE5dbFD9003bFf9dF5feB2f4F445Ca00fb121fb83'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xE5dbFD9003bFf9dF5feB2f4F445Ca00fb121fb83',
     },
     'LTC-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x74E72F37A8c415c8f1a98Ed42E78Ff997435791D'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x74E72F37A8c415c8f1a98Ed42E78Ff997435791D',
     },
     'SXP-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xE188A9875af525d25334d75F3327863B2b8cd0F1'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xE188A9875af525d25334d75F3327863B2b8cd0F1',
     },
     'TRX-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xF4C5e535756D11994fCBB12Ba8adD0192D9b88be'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xF4C5e535756D11994fCBB12Ba8adD0192D9b88be',
     },
     'JPY-USD': {
         [Chain.POLYGON_MAINNET]: '0xD647a6fC9BC6402301583C91decC5989d8Bc382D',
@@ -68,14 +68,14 @@ export const chainlinkOracles = {
         [Chain.BNB_SMART_CHAIN_MAINNET]: '0xca236E327F629f9Fc2c30A4E95775EbF0B89fac8',
     },
     'TUSD-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xa3334A9762090E827413A7495AfeCE76F41dFc06'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xa3334A9762090E827413A7495AfeCE76F41dFc06',
     },
     'LINK-MATIC': {
         [Chain.POLYGON_MAINNET]: '0x5787BefDc0ECd210Dfa948264631CD53E68F7802',
     },
     'MATIC-USD': {
         [Chain.POLYGON_MAINNET]: '0xAB594600376Ec9fD91F8e885dADF0CE036862dE0',
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x7CA57b0cA6367191c94C8914d7Df09A57655905f'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x7CA57b0cA6367191c94C8914d7Df09A57655905f',
     },
     'MATICX-USD': {
         [Chain.POLYGON_MAINNET]: '0x5d37E4b374E6907de8Fc7fb33EE3b0af403C7403',
@@ -94,16 +94,16 @@ export const chainlinkOracles = {
     'USDT-USD': {
         [Chain.ETHEREUM_MAINNET]: '0x3E7d1eAB13ad0104d2750B8863b489D65364e32D',
         [Chain.POLYGON_MAINNET]: '0x0a6513e40db6eb1b165753ad52e80663aea50545',
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xB97Ad0E74fa7d920791E90258A6E2085088b4320'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xB97Ad0E74fa7d920791E90258A6E2085088b4320',
     },
     'VAI-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x058316f8Bb13aCD442ee7A216C7b60CFB4Ea1B53'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x058316f8Bb13aCD442ee7A216C7b60CFB4Ea1B53',
     },
     'XRP-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x93A67D414896A280bF8FFB3b389fE3686E014fda'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x93A67D414896A280bF8FFB3b389fE3686E014fda',
     },
     'WIN-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x9e7377E194E41d63795907c92c3EB351a2eb0233'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x9e7377E194E41d63795907c92c3EB351a2eb0233',
     },
     'EUR-USD': {
         [Chain.POLYGON_MAINNET]: '0x73366Fe0AA0Ded304479862808e02506FE556a98',
@@ -114,13 +114,13 @@ export const chainlinkOracles = {
     },
     'AAVE-USD': {
         [Chain.ETHEREUM_MAINNET]: '0x547a514d5e3769680Ce22B2361c10Ea13619e8a9',
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xA8357BF572460fC40f4B0aCacbB2a6A61c89f475'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xA8357BF572460fC40f4B0aCacbB2a6A61c89f475',
     },
     'ADA-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xa767f745331D267c7751297D982b050c93985627'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xa767f745331D267c7751297D982b050c93985627',
     },
     'BCH-USD': {
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x43d80f616DAf0b0B42a928EeD32147dC59027D41'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0x43d80f616DAf0b0B42a928EeD32147dC59027D41',
     },
     'BAT-ETH': {
         [Chain.ETHEREUM_MAINNET]: '0x0d16d4528239e9ee52fa531af613AcdB23D88c94',
@@ -128,7 +128,7 @@ export const chainlinkOracles = {
     'UNI-USD': {
         [Chain.ETHEREUM_MAINNET]: '0x553303d460EE0afB37EdFf9bE42922D8FF63220e',
         [Chain.POLYGON_MAINNET]: '0xdf0Fb4e4F928d2dCB76f438575fDD8682386e13C',
-        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xb57f259E7C24e56a1dA00F66b55A5640d9f9E7e4'
+        [Chain.BNB_SMART_CHAIN_MAINNET]: '0xb57f259E7C24e56a1dA00F66b55A5640d9f9E7e4',
     },
     'YFI-USD': {
         [Chain.ETHEREUM_MAINNET]: '0xA027702dbb89fbd58938e4324ac03B58d812b0E1',
@@ -144,19 +144,20 @@ export const chainlinkOracles = {
     },
     'MKR-USD': {
         [Chain.ETHEREUM_MAINNET]: '0xec1D1B3b0443256cc3860e24a46F108e699484Aa',
-        [Chain.POLYGON_MAINNET]: '0xa070427bF5bA5709f70e98b94Cb2F435a242C46C'
+        [Chain.POLYGON_MAINNET]: '0xa070427bF5bA5709f70e98b94Cb2F435a242C46C',
     },
     'COMP-USD': {
         [Chain.ETHEREUM_MAINNET]: '0xdbd020CAeF83eFd542f4De03e3cF0C28A4428bd5',
-        [Chain.POLYGON_MAINNET]: '0x2A8758b7257102461BC958279054e372C2b1bDE6'
+        [Chain.POLYGON_MAINNET]: '0x2A8758b7257102461BC958279054e372C2b1bDE6',
     },
     'WSTETH-ETH': {
         [Chain.POLYGON_MAINNET]: '0x10f964234cae09cB6a9854B56FF7D4F38Cda5E6a',
     },
 };
 export const getChainLinkKeys = (chainId) => {
+    return Object.keys(chainlinkOracles).filter(
     // @ts-ignore
-    return Object.keys(chainlinkOracles).filter((x) => chainlinkOracles[x][chainId] !== undefined);
+    (x) => chainlinkOracles[x][chainId] !== undefined);
 };
 export const chainlinkOraclesEthereum = {
     '1INCH-USD': {

package/dist/prices/main-prices/fetchOracleData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchOracleData.d.ts","sourceRoot":"","sources":["../../../src/prices/main-prices/fetchOracleData.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAKlD,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,EAAE,cAAY,KAAG,MAY7D,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,OAAO,MAAM,EACb,eAAe,MAAM,EACrB,SAAS,MAAM,KACd,MAYF,CAAA;AAOD,UAAU,UAAU;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CACtB;AAID;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAAE,EAClB,cAAc,oBAAoB,KACjC,OAAO,CAAC,UAAU,CAiJpB,CAAA"}
+{"version":3,"file":"fetchOracleData.d.ts","sourceRoot":"","sources":["../../../src/prices/main-prices/fetchOracleData.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAKlD,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,EAAE,cAAY,KAAG,MAY7D,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,OAAO,MAAM,EACb,eAAe,MAAM,EACrB,SAAS,MAAM,KACd,MAYF,CAAA;AAOD,UAAU,UAAU;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CACtB;AAID;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAAE,EAClB,cAAc,oBAAoB,KACjC,OAAO,CAAC,UAAU,CA8JpB,CAAA"}

package/dist/prices/main-prices/fetchOracleData.js

@@ -44,97 +44,117 @@ const RWA_DYNAMIC_ORACLE = '0xA96abbe61AfEdEB0D14a20440Ae7100D9aB4882f';
  * Fetches Aave and uniswap V2 oracle data
  */
 export const fetchMainPrices = async (chainIds, getEvmClient) => {
-    let promises = chainIds.map((chainId) => {
+    const multicallPromises = chainIds.map(async (chainId) => {
         const aaveForks = AAVES_PER_CHAIN[chainId];
-        let reservesToQuery = aaveForks?.map((a) => ({ fork: a, assets: getAaveAssets(chainId, a) }));
-        let handled = [];
-        let queries = [];
-        reservesToQuery?.forEach((e) => {
-            const newOnes = e.assets.filter((a) => !handled.includes(a));
-            if (newOnes.length > 0) {
+        const reservesToQuery = aaveForks?.map((a) => ({
+            fork: a,
+            assets: getAaveAssets(chainId, a),
+        })) ?? [];
+        const handled = new Set();
+        const queries = [];
+        for (const e of reservesToQuery) {
+            const newAssets = e.assets.filter((a) => !handled.has(a));
+            if (newAssets.length > 0) {
                 queries.push({
-                    assets: newOnes,
+                    assets: newAssets,
                     // @ts-ignore
                     oracle: AAVE_STYLE_ORACLES[e.fork][chainId],
                     fork: e.fork,
                 });
-                handled = [...handled, ...newOnes];
+                newAssets.forEach((a) => handled.add(a));
             }
-        });
-        const morphoQueries = (MrophoOracles[chainId] ?? []).filter((a) => !handled.includes(a.collateralAsset) || !handled.includes(a.loanAsset));
+        }
+        const morphoQueries = (MrophoOracles[chainId] ?? []).filter((a) => !handled.has(a.collateralAsset) || !handled.has(a.loanAsset));
         const morphoCalls = getMorphoCalls(morphoQueries);
-        const callAave = getAaveCalls(queries);
-        const [callsChainLink, chainLinkNames] = getChainLinkCalls(chainId);
-        const uniswapV2Calls = getUniswapV2Calls(chainId);
+        const aaveCalls = getAaveCalls(queries);
+        const [chainlinkCalls, chainlinkNames] = getChainLinkCalls(chainId);
+        const uniswapCalls = getUniswapV2Calls(chainId);
         const [api3Calls, api3Names] = getApi3Calls(chainId);
         const [rwaCalls, rwaNames] = getRWADynamicOracleCalls(chainId);
-        return multicallViemAbiArray(chainId, [
+        const allCalls = [
+            ...chainlinkCalls,
+            ...aaveCalls,
+            ...uniswapCalls,
+            ...api3Calls,
+            ...rwaCalls,
+            ...morphoCalls,
+        ];
+        const abis = [
             ...ChainLinkAggregatorAbi,
             ...UniswapV2PairAbi,
             ...AaveOracleAbi,
             ...Api3OracleAbi,
             ...RWADynamicOracleAbi,
             ...ProxyOracleAbi,
-        ], [
-            ...callsChainLink,
-            ...callAave,
-            ...uniswapV2Calls,
-            ...api3Calls,
-            ...rwaCalls,
-            ...morphoCalls,
-        ], getEvmClient).then((multicallResult) => {
-            const chainLinkResults = multicallResult.slice(0, callsChainLink.length);
-            const aaveResult = multicallResult.slice(callsChainLink.length, callsChainLink.length + callAave.length);
-            const chainLinkData = parseChainLinkResults(chainId, chainLinkResults, chainLinkNames);
-            // @ts-ignore
-            const aaveData = parseAaveResults(chainId, aaveResult, queries);
-            const uniswapResult = multicallResult.slice(callsChainLink.length + callAave.length, callsChainLink.length + callAave.length + uniswapV2Calls.length);
-            const api3Result = multicallResult.slice(callsChainLink.length + callAave.length + uniswapV2Calls.length, callsChainLink.length +
-                callAave.length +
-                uniswapV2Calls.length +
-                api3Calls.length);
-            const uniswapData = parseUniswapV2results(uniswapResult, chainId);
-            const api3Data = parseApi3Results(chainId, api3Result, api3Names);
-            const rwaResult = multicallResult.slice(callsChainLink.length +
-                callAave.length +
-                uniswapV2Calls.length +
-                api3Calls.length, callsChainLink.length +
-                callAave.length +
-                uniswapV2Calls.length +
-                api3Calls.length +
-                rwaCalls.length);
-            const rwaData = parseRWADynamicOracleResults(chainId, rwaResult, rwaNames);
-            const morphoResult = multicallResult.slice(callsChainLink.length +
-                callAave.length +
-                uniswapV2Calls.length +
-                api3Calls.length +
-                rwaCalls.length, callsChainLink.length +
-                callAave.length +
-                uniswapV2Calls.length +
-                api3Calls.length +
-                morphoCalls.length);
-            const prices = {
-                ...uniswapData,
-                ...aaveData,
-                ...chainLinkData,
-                ...api3Data,
-                ...rwaData,
-            };
-            const morphoData = parseMorphoResults(chainId, morphoResult, morphoQueries, prices);
-            return {
-                ...prices,
-                ...morphoData,
-            };
-        });
-    });
-    promises.push(fetchDefillamaData());
-    promises.push(fetchPendlePrices());
-    const result = await Promise.all(promises);
-    let data = {};
-    result.forEach((r) => {
-        data = { ...data, ...r };
+        ];
+        const result = await multicallViemAbiArray(chainId, abis, allCalls, getEvmClient);
+        return {
+            chainId,
+            result,
+            meta: {
+                queries,
+                chainlink: { calls: chainlinkCalls, names: chainlinkNames },
+                api3: { calls: api3Calls, names: api3Names },
+                rwa: { calls: rwaCalls, names: rwaNames },
+                morpho: { queries: morphoQueries },
+                uniswapCalls,
+                aaveCalls,
+            },
+        };
     });
-    return data;
+    const otherDataPromises = [fetchDefillamaData(), fetchPendlePrices()];
+    const [chainResults, ...otherResults] = await Promise.all([
+        Promise.all(multicallPromises),
+        ...otherDataPromises,
+    ]);
+    let allPrices = {};
+    // Parse all except morpho first
+    for (const { chainId, result, meta: { queries, chainlink, api3, rwa, uniswapCalls, aaveCalls }, } of chainResults) {
+        let offset = 0;
+        const chainlinkSlice = result.slice(offset, offset + chainlink.calls.length);
+        const chainlinkData = parseChainLinkResults(chainId, chainlinkSlice, chainlink.names);
+        offset += chainlink.calls.length;
+        const aaveSlice = result.slice(offset, offset + aaveCalls.length);
+        const aaveData = parseAaveResults(chainId, aaveSlice, queries);
+        offset += aaveCalls.length;
+        const uniswapSlice = result.slice(offset, offset + uniswapCalls.length);
+        const uniswapData = parseUniswapV2results(uniswapSlice, chainId);
+        offset += uniswapCalls.length;
+        const api3Slice = result.slice(offset, offset + api3.calls.length);
+        const api3Data = parseApi3Results(chainId, api3Slice, api3.names);
+        offset += api3.calls.length;
+        const rwaSlice = result.slice(offset, offset + rwa.calls.length);
+        const rwaData = parseRWADynamicOracleResults(chainId, rwaSlice, rwa.names);
+        offset += rwa.calls.length;
+        allPrices = {
+            ...allPrices,
+            ...chainlinkData,
+            ...aaveData,
+            ...uniswapData,
+            ...api3Data,
+            ...rwaData,
+        };
+    }
+    allPrices = { ...allPrices, ...otherResults[0], ...otherResults[1] };
+    // Parse morpho data (needs allPrices)
+    for (const { chainId, result, meta: { morpho, chainlink, aaveCalls, uniswapCalls, api3, rwa }, } of chainResults) {
+        const morphoOffset = chainlink.calls.length +
+            aaveCalls.length +
+            uniswapCalls.length +
+            api3.calls.length +
+            rwa.calls.length;
+        const morphoResult = result.slice(morphoOffset);
+        const morphoData = parseMorphoResults(chainId, morphoResult, morpho.queries, allPrices);
+        allPrices = {
+            ...allPrices,
+            ...morphoData,
+        };
+    }
+    // Merge with defillama + pendle prices
+    for (const r of otherResults) {
+        allPrices = { ...allPrices, ...r };
+    }
+    return allPrices;
 };
 /**
  * Gets the calls foir the uniswap pools
@@ -296,8 +316,6 @@ const parseMorphoResults = (chainId, data, queries, donePrices = {}) => {
         const oracleIdCollateral = ASSET_META[chainId][collateralAsset]?.assetGroup ??
             chainId + '-' + collateralAsset;
         const collateralPrice = donePrices[oracleIdCollateral];
-        console.log('debtPrice', oracleId, debtPrice);
-        console.log('collateralPrice', oracleIdCollateral, collateralPrice);
         const priceDebtToCollateral = formatMorphoPrice(d.toString(), loanAssetDecimals, collateralAssetDecimals);
         if (debtPrice) {
             if (!prices[oracleIdCollateral])

package/dist/yields/index.js

@@ -114,7 +114,7 @@ export const fetchGeneralYields = async () => {
         const res = await fetch(FeedData.HYPE).then((r) => r.json());
         return {
             [wstHype]: res.wstHYPE.latestApr,
-            [hyUSD]: res.kHYPE.latestApr,
+            [kHYPE]: res.kHYPE.latestApr,
         };
     });
     const cbethPromise = safeFetch('CBETH', async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1delta/margin-fetcher",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/prices/defillama/index.ts

@@ -113,9 +113,14 @@ const WS = '0x039e2fb66102314ce7b64ce5ce3e5183bc94ad38'
 const prefixFantom = 'fantom:'
 const WFTM = '0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83'
 
+const prefixPolygon = 'polygon:'
+const TRUMATIC = '0xf33687811f3ad0cd6b48dd4b39f9f977bd7165a2'
+
 const prefixHyperEVM = 'hyperliquid:'
 
 const WYPE = '0x5555555555555555555555555555555555555555'
+const WSTHYPE = '0x94e8396e0869c9f2200760af0621afd240e1cf38'
+const kHYPE = '0xfd739d4e423301ce9385c1fb8850539d657c296d'
 
 // const prefixKaia = 'kaia:'
 // const WKAIA = '0x19aac5f612f524b754ca7e7c41cbfa2e981a4432'
@@ -129,8 +134,11 @@ const datasBase = [AERO].map((d) => prefixBase + d).join(',')
 const datasCore = [WCORE].map((d) => prefixCore + d).join(',')
 const datasMetis = [WMETIS].map((d) => prefixMetis + d).join(',')
 const datasFantom = [WFTM].map((d) => prefixFantom + d).join(',')
+const datasPolygon = [TRUMATIC].map((d) => prefixPolygon + d).join(',')
 const datasSonic = [WS].map((d) => prefixSonic + d).join(',')
-const datasHyperEvm = [WYPE].map((d) => prefixHyperEVM + d).join(',')
+const datasHyperEvm = [WYPE, WSTHYPE, kHYPE]
+  .map((d) => prefixHyperEVM + d)
+  .join(',')
 // const datasKaia = [WKAIA].map((d) => prefixKaia + d).join(',')
 
 const URL = `https://coins.llama.fi/prices/current/${[
@@ -143,8 +151,9 @@ const URL = `https://coins.llama.fi/prices/current/${[
   datasMetis,
   datasFantom,
   datasHyperEvm,
-//   datasKaia,
+  //   datasKaia,
   datasSonic, //
+  datasPolygon,
 ].join(',')}?searchWidth=4h`
 const URL_HIST = (ref: number) =>
   `https://coins.llama.fi/prices/historical/${ref}/${[
@@ -158,6 +167,7 @@ const URL_HIST = (ref: number) =>
     datasFantom,
     // datasKaia,
     datasHyperEvm,
+    datasPolygon,
     datasSonic, //
   ].join(',')}?searchWidth=4h`
 
@@ -222,6 +232,9 @@ const SYMBOL_MAP = {
   wkaia: 'KAIA',
   savax: 'SAVAX',
   whype: 'WHYPE',
+  khype: 'Kinetiq Staked HYPE::kHYPE',
+  wsthype: 'Staked HYPE Shares::WSTHYPE',
+  trumatic: 'TRUMATIC',
 }
 
 export async function fetchDefillamaData() {
@@ -302,6 +315,7 @@ export async function fetchDefillamaHistData() {
     histPrices['SUBTC'] = histPrices['WBTC']
     histPrices['IBTC'] = histPrices['WBTC']
     histPrices['ENZOBTC'] = histPrices['WBTC']
+    histPrices['CBBTC'] = histPrices['WBTC']
     histPrices['PUMPBTC'] = histPrices['WBTC']
 
     return histPrices

package/src/prices/main-prices/addresses/chainlink.ts

@@ -1,18 +1,16 @@
-import { Chain } from "@1delta/asset-registry"
-
+import { Chain } from '@1delta/asset-registry'
 
 export enum ChainlinkAggregatorIndexes {
   roundId = 0,
   answer,
   startedAt,
   updatedAt,
-  answeredInRound
+  answeredInRound,
 }
 
-
 export const chainlinkOracles = {
   'MIMATIC-USD': {
-    [Chain.POLYGON_MAINNET]: '0xd8d483d813547cfb624b8dc33a00f2fcbcd2d428'
+    [Chain.POLYGON_MAINNET]: '0xd8d483d813547cfb624b8dc33a00f2fcbcd2d428',
   },
   'BTC-ETH': {
     [Chain.POLYGON_MAINNET]: '0x19b0F0833C78c0848109E3842D34d2fDF2cA69BA',
@@ -20,47 +18,60 @@ export const chainlinkOracles = {
   'BTC-USD': {
     [Chain.POLYGON_MAINNET]: '0xc907E116054Ad103354f2D350FD2514433D57F6f',
     [Chain.ETHEREUM_MAINNET]: '0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c',
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x264990fbd0A4796A3E3d8E37C4d5F87a3aCa5Ebf',
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x264990fbd0A4796A3E3d8E37C4d5F87a3aCa5Ebf',
   },
   'DAI-USD': {
     [Chain.POLYGON_MAINNET]: '0x4746DeC9e833A82EC7C2C1356372CcF2cfcD2F3D',
     [Chain.ETHEREUM_MAINNET]: '0xAed0c38402a5d19df6E4c03F4E2DceD6e29c1ee9',
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x132d3C0B1D2cEa0BC552588063bdBb210FDeecfA',
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x132d3C0B1D2cEa0BC552588063bdBb210FDeecfA',
   },
   'ETH-USD': {
     [Chain.POLYGON_MAINNET]: '0xF9680D99D6C9589e2a93a78A04A279e509205945',
     [Chain.ETHEREUM_MAINNET]: '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419',
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x9ef1B8c0E4F7dc8bF5719Ea496883DC6401d5b2e',
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x9ef1B8c0E4F7dc8bF5719Ea496883DC6401d5b2e',
   },
   'BNB-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x0567F2323251f0Aab15c8dFb1967E4e8A7D42aeE'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x0567F2323251f0Aab15c8dFb1967E4e8A7D42aeE',
   },
   'CAKE-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xB6064eD41d4f67e353768aA239cA86f4F73665a1'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xB6064eD41d4f67e353768aA239cA86f4F73665a1',
   },
   'DOGE-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x3AB0A0d137D4F946fBB19eecc6e92E64660231C8'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x3AB0A0d137D4F946fBB19eecc6e92E64660231C8',
   },
   'DOT-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xC333eb0086309a16aa7c8308DfD32c8BBA0a2592'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xC333eb0086309a16aa7c8308DfD32c8BBA0a2592',
   },
   'BUSD-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xcBb98864Ef56E9042e7d2efef76141f15731B82f'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xcBb98864Ef56E9042e7d2efef76141f15731B82f',
   },
   'BETH-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x2A3796273d47c4eD363b361D3AEFb7F7E2A13782'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x2A3796273d47c4eD363b361D3AEFb7F7E2A13782',
   },
   'FIL-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xE5dbFD9003bFf9dF5feB2f4F445Ca00fb121fb83'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xE5dbFD9003bFf9dF5feB2f4F445Ca00fb121fb83',
   },
   'LTC-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x74E72F37A8c415c8f1a98Ed42E78Ff997435791D'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x74E72F37A8c415c8f1a98Ed42E78Ff997435791D',
   },
   'SXP-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xE188A9875af525d25334d75F3327863B2b8cd0F1'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xE188A9875af525d25334d75F3327863B2b8cd0F1',
   },
   'TRX-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xF4C5e535756D11994fCBB12Ba8adD0192D9b88be'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xF4C5e535756D11994fCBB12Ba8adD0192D9b88be',
   },
   'JPY-USD': {
     [Chain.POLYGON_MAINNET]: '0xD647a6fC9BC6402301583C91decC5989d8Bc382D',
@@ -68,17 +79,20 @@ export const chainlinkOracles = {
   'LINK-USD': {
     [Chain.POLYGON_MAINNET]: '0xd9FFdb71EbE7496cC440152d43986Aae0AB76665',
     [Chain.ETHEREUM_MAINNET]: '0x2c1d072e956AFFC0D435Cb7AC38EF18d24d9127c',
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xca236E327F629f9Fc2c30A4E95775EbF0B89fac8',
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xca236E327F629f9Fc2c30A4E95775EbF0B89fac8',
   },
   'TUSD-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xa3334A9762090E827413A7495AfeCE76F41dFc06'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xa3334A9762090E827413A7495AfeCE76F41dFc06',
   },
   'LINK-MATIC': {
     [Chain.POLYGON_MAINNET]: '0x5787BefDc0ECd210Dfa948264631CD53E68F7802',
   },
   'MATIC-USD': {
     [Chain.POLYGON_MAINNET]: '0xAB594600376Ec9fD91F8e885dADF0CE036862dE0',
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x7CA57b0cA6367191c94C8914d7Df09A57655905f'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x7CA57b0cA6367191c94C8914d7Df09A57655905f',
   },
   'MATICX-USD': {
     [Chain.POLYGON_MAINNET]: '0x5d37E4b374E6907de8Fc7fb33EE3b0af403C7403',
@@ -87,44 +101,52 @@ export const chainlinkOracles = {
     [Chain.POLYGON_MAINNET]: '0x97371dF4492605486e23Da797fA68e55Fc38a13f',
   },
   'XVS-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xBF63F430A79D4036A5900C19818aFf1fa710f206',
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xBF63F430A79D4036A5900C19818aFf1fa710f206',
   },
   'USDC-USD': {
     [Chain.POLYGON_MAINNET]: '0xfE4A8cc5b5B2366C1B58Bea3858e81843581b2F7',
     [Chain.ETHEREUM_MAINNET]: '0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6',
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x51597f405303C4377E36123cBc172b13269EA163',
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x51597f405303C4377E36123cBc172b13269EA163',
   },
   'USDT-USD': {
     [Chain.ETHEREUM_MAINNET]: '0x3E7d1eAB13ad0104d2750B8863b489D65364e32D',
     [Chain.POLYGON_MAINNET]: '0x0a6513e40db6eb1b165753ad52e80663aea50545',
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xB97Ad0E74fa7d920791E90258A6E2085088b4320'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xB97Ad0E74fa7d920791E90258A6E2085088b4320',
   },
   'VAI-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x058316f8Bb13aCD442ee7A216C7b60CFB4Ea1B53'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x058316f8Bb13aCD442ee7A216C7b60CFB4Ea1B53',
   },
   'XRP-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x93A67D414896A280bF8FFB3b389fE3686E014fda'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x93A67D414896A280bF8FFB3b389fE3686E014fda',
   },
   'WIN-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x9e7377E194E41d63795907c92c3EB351a2eb0233'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x9e7377E194E41d63795907c92c3EB351a2eb0233',
   },
   'EUR-USD': {
     [Chain.POLYGON_MAINNET]: '0x73366Fe0AA0Ded304479862808e02506FE556a98',
   },
-  'SAND-USD': {
-  },
+  'SAND-USD': {},
   'USDT-USDC': {
     [Chain.POLYGON_MAINNET]: '0x0A6513e40db6EB1b165753AD52E80663aeA50545',
   },
   'AAVE-USD': {
     [Chain.ETHEREUM_MAINNET]: '0x547a514d5e3769680Ce22B2361c10Ea13619e8a9',
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xA8357BF572460fC40f4B0aCacbB2a6A61c89f475'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xA8357BF572460fC40f4B0aCacbB2a6A61c89f475',
   },
   'ADA-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xa767f745331D267c7751297D982b050c93985627'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xa767f745331D267c7751297D982b050c93985627',
   },
   'BCH-USD': {
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0x43d80f616DAf0b0B42a928EeD32147dC59027D41'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0x43d80f616DAf0b0B42a928EeD32147dC59027D41',
   },
   'BAT-ETH': {
     [Chain.ETHEREUM_MAINNET]: '0x0d16d4528239e9ee52fa531af613AcdB23D88c94',
@@ -132,7 +154,8 @@ export const chainlinkOracles = {
   'UNI-USD': {
     [Chain.ETHEREUM_MAINNET]: '0x553303d460EE0afB37EdFf9bE42922D8FF63220e',
     [Chain.POLYGON_MAINNET]: '0xdf0Fb4e4F928d2dCB76f438575fDD8682386e13C',
-    [Chain.BNB_SMART_CHAIN_MAINNET]: '0xb57f259E7C24e56a1dA00F66b55A5640d9f9E7e4'
+    [Chain.BNB_SMART_CHAIN_MAINNET]:
+      '0xb57f259E7C24e56a1dA00F66b55A5640d9f9E7e4',
   },
   'YFI-USD': {
     [Chain.ETHEREUM_MAINNET]: '0xA027702dbb89fbd58938e4324ac03B58d812b0E1',
@@ -148,11 +171,11 @@ export const chainlinkOracles = {
   },
   'MKR-USD': {
     [Chain.ETHEREUM_MAINNET]: '0xec1D1B3b0443256cc3860e24a46F108e699484Aa',
-    [Chain.POLYGON_MAINNET]: '0xa070427bF5bA5709f70e98b94Cb2F435a242C46C'
+    [Chain.POLYGON_MAINNET]: '0xa070427bF5bA5709f70e98b94Cb2F435a242C46C',
   },
   'COMP-USD': {
     [Chain.ETHEREUM_MAINNET]: '0xdbd020CAeF83eFd542f4De03e3cF0C28A4428bd5',
-    [Chain.POLYGON_MAINNET]: '0x2A8758b7257102461BC958279054e372C2b1bDE6'
+    [Chain.POLYGON_MAINNET]: '0x2A8758b7257102461BC958279054e372C2b1bDE6',
   },
   'WSTETH-ETH': {
     [Chain.POLYGON_MAINNET]: '0x10f964234cae09cB6a9854B56FF7D4F38Cda5E6a',
@@ -160,8 +183,10 @@ export const chainlinkOracles = {
 }
 
 export const getChainLinkKeys = (chainId: string): string[] => {
-  // @ts-ignore
-  return Object.keys(chainlinkOracles).filter((x) => chainlinkOracles[x][chainId] !== undefined)
+  return Object.keys(chainlinkOracles).filter(
+    // @ts-ignore
+    (x) => chainlinkOracles[x][chainId] !== undefined,
+  )
 }
 
 export const chainlinkOraclesEthereum = {

package/src/prices/main-prices/fetchOracleData.ts

@@ -73,150 +73,163 @@ export const fetchMainPrices = async (
   chainIds: string[],
   getEvmClient: GetEvmClientFunction,
 ): Promise<OracleData> => {
-  let promises = chainIds.map((chainId) => {
+  const multicallPromises = chainIds.map(async (chainId) => {
     const aaveForks = AAVES_PER_CHAIN[chainId]
-    let reservesToQuery: { fork: string; assets: string[] }[] = aaveForks?.map(
-      (a) => ({ fork: a, assets: getAaveAssets(chainId, a) }),
-    )
-    let handled: string[] = []
-    let queries: QueryAave[] = []
-    reservesToQuery?.forEach((e) => {
-      const newOnes = e.assets.filter((a) => !handled.includes(a))
-      if (newOnes.length > 0) {
+    const reservesToQuery =
+      aaveForks?.map((a) => ({
+        fork: a,
+        assets: getAaveAssets(chainId, a),
+      })) ?? []
+
+    const handled: Set<string> = new Set()
+    const queries: QueryAave[] = []
+
+    for (const e of reservesToQuery) {
+      const newAssets = e.assets.filter((a) => !handled.has(a))
+      if (newAssets.length > 0) {
         queries.push({
-          assets: newOnes,
+          assets: newAssets,
           // @ts-ignore
           oracle: AAVE_STYLE_ORACLES[e.fork][chainId],
           fork: e.fork,
         })
-        handled = [...handled, ...newOnes]
+        newAssets.forEach((a) => handled.add(a))
       }
-    })
+    }
 
     const morphoQueries = (MrophoOracles[chainId] ?? []).filter(
-      (a) =>
-        !handled.includes(a.collateralAsset) || !handled.includes(a.loanAsset),
+      (a) => !handled.has(a.collateralAsset) || !handled.has(a.loanAsset),
     )
 
     const morphoCalls = getMorphoCalls(morphoQueries)
-
-    const callAave = getAaveCalls(queries)
-
-    const [callsChainLink, chainLinkNames] = getChainLinkCalls(chainId)
-
-    const uniswapV2Calls = getUniswapV2Calls(chainId)
-
+    const aaveCalls = getAaveCalls(queries)
+    const [chainlinkCalls, chainlinkNames] = getChainLinkCalls(chainId)
+    const uniswapCalls = getUniswapV2Calls(chainId)
     const [api3Calls, api3Names] = getApi3Calls(chainId)
-
     const [rwaCalls, rwaNames] = getRWADynamicOracleCalls(chainId)
 
-    return multicallViemAbiArray(
+    const allCalls = [
+      ...chainlinkCalls,
+      ...aaveCalls,
+      ...uniswapCalls,
+      ...api3Calls,
+      ...rwaCalls,
+      ...morphoCalls,
+    ]
+
+    const abis = [
+      ...ChainLinkAggregatorAbi,
+      ...UniswapV2PairAbi,
+      ...AaveOracleAbi,
+      ...Api3OracleAbi,
+      ...RWADynamicOracleAbi,
+      ...ProxyOracleAbi,
+    ]
+
+    const result = await multicallViemAbiArray(
       chainId,
-      [
-        ...ChainLinkAggregatorAbi,
-        ...UniswapV2PairAbi,
-        ...AaveOracleAbi,
-        ...Api3OracleAbi,
-        ...RWADynamicOracleAbi,
-        ...ProxyOracleAbi,
-      ],
-      [
-        ...callsChainLink,
-        ...callAave,
-        ...uniswapV2Calls,
-        ...api3Calls,
-        ...rwaCalls,
-        ...morphoCalls,
-      ],
+      abis,
+      allCalls,
       getEvmClient,
-    ).then((multicallResult) => {
-      const chainLinkResults = multicallResult.slice(0, callsChainLink.length)
-
-      const aaveResult = multicallResult.slice(
-        callsChainLink.length,
-        callsChainLink.length + callAave.length,
-      )
-
-      const chainLinkData = parseChainLinkResults(
-        chainId,
-        chainLinkResults,
-        chainLinkNames,
-      )
-      // @ts-ignore
-      const aaveData = parseAaveResults(chainId, aaveResult, queries)
+    )
 
-      const uniswapResult = multicallResult.slice(
-        callsChainLink.length + callAave.length,
-        callsChainLink.length + callAave.length + uniswapV2Calls.length,
-      )
+    return {
+      chainId,
+      result,
+      meta: {
+        queries,
+        chainlink: { calls: chainlinkCalls, names: chainlinkNames },
+        api3: { calls: api3Calls, names: api3Names },
+        rwa: { calls: rwaCalls, names: rwaNames },
+        morpho: { queries: morphoQueries },
+        uniswapCalls,
+        aaveCalls,
+      },
+    }
+  })
 
-      const api3Result = multicallResult.slice(
-        callsChainLink.length + callAave.length + uniswapV2Calls.length,
-        callsChainLink.length +
-          callAave.length +
-          uniswapV2Calls.length +
-          api3Calls.length,
-      )
+  const otherDataPromises = [fetchDefillamaData(), fetchPendlePrices()]
+  const [chainResults, ...otherResults] = await Promise.all([
+    Promise.all(multicallPromises),
+    ...otherDataPromises,
+  ])
 
-      const uniswapData = parseUniswapV2results(uniswapResult, chainId)
+  let allPrices: OracleData = {}
 
-      const api3Data = parseApi3Results(chainId, api3Result, api3Names)
+  // Parse all except morpho first
+  for (const {
+    chainId,
+    result,
+    meta: { queries, chainlink, api3, rwa, uniswapCalls, aaveCalls },
+  } of chainResults) {
+    let offset = 0
 
-      const rwaResult = multicallResult.slice(
-        callsChainLink.length +
-          callAave.length +
-          uniswapV2Calls.length +
-          api3Calls.length,
-        callsChainLink.length +
-          callAave.length +
-          uniswapV2Calls.length +
-          api3Calls.length +
-          rwaCalls.length,
-      )
+    const chainlinkSlice = result.slice(offset, offset + chainlink.calls.length)
+    const chainlinkData = parseChainLinkResults(
+      chainId,
+      chainlinkSlice,
+      chainlink.names,
+    )
+    offset += chainlink.calls.length
+
+    const aaveSlice = result.slice(offset, offset + aaveCalls.length)
+    const aaveData = parseAaveResults(chainId, aaveSlice, queries)
+    offset += aaveCalls.length
+
+    const uniswapSlice = result.slice(offset, offset + uniswapCalls.length)
+    const uniswapData = parseUniswapV2results(uniswapSlice, chainId)
+    offset += uniswapCalls.length
+
+    const api3Slice = result.slice(offset, offset + api3.calls.length)
+    const api3Data = parseApi3Results(chainId, api3Slice, api3.names)
+    offset += api3.calls.length
+
+    const rwaSlice = result.slice(offset, offset + rwa.calls.length)
+    const rwaData = parseRWADynamicOracleResults(chainId, rwaSlice, rwa.names)
+    offset += rwa.calls.length
+
+    allPrices = {
+      ...allPrices,
+      ...chainlinkData,
+      ...aaveData,
+      ...uniswapData,
+      ...api3Data,
+      ...rwaData,
+    }
+  }
+  allPrices = { ...allPrices, ...otherResults[0], ...otherResults[1] }
+  // Parse morpho data (needs allPrices)
+  for (const {
+    chainId,
+    result,
+    meta: { morpho, chainlink, aaveCalls, uniswapCalls, api3, rwa },
+  } of chainResults) {
+    const morphoOffset =
+      chainlink.calls.length +
+      aaveCalls.length +
+      uniswapCalls.length +
+      api3.calls.length +
+      rwa.calls.length
+    const morphoResult = result.slice(morphoOffset)
+    const morphoData = parseMorphoResults(
+      chainId,
+      morphoResult,
+      morpho.queries,
+      allPrices,
+    )
 
-      const rwaData = parseRWADynamicOracleResults(chainId, rwaResult, rwaNames)
-
-      const morphoResult = multicallResult.slice(
-        callsChainLink.length +
-          callAave.length +
-          uniswapV2Calls.length +
-          api3Calls.length +
-          rwaCalls.length,
-        callsChainLink.length +
-          callAave.length +
-          uniswapV2Calls.length +
-          api3Calls.length +
-          morphoCalls.length,
-      )
-      const prices = {
-        ...uniswapData,
-        ...aaveData,
-        ...chainLinkData,
-        ...api3Data,
-        ...rwaData,
-      }
-      const morphoData = parseMorphoResults(
-        chainId,
-        morphoResult,
-        morphoQueries,
-        prices,
-      )
+    allPrices = {
+      ...allPrices,
+      ...morphoData,
+    }
+  }
 
-      return {
-        ...prices,
-        ...morphoData,
-      }
-    })
-  })
-  promises.push(fetchDefillamaData())
-  promises.push(fetchPendlePrices())
-  const result = await Promise.all(promises)
-  let data: any = {}
-  result.forEach((r) => {
-    data = { ...data, ...r }
-  })
+  // Merge with defillama + pendle prices
+  for (const r of otherResults) {
+    allPrices = { ...allPrices, ...r }
+  }
 
-  return data
+  return allPrices
 }
 
 /**
@@ -412,7 +425,6 @@ const parseMorphoResults = (
   donePrices: any = {},
 ) => {
   let prices: any = {}
-
   data.forEach((d, i) => {
     const details = queries[i]
     const {
@@ -421,6 +433,7 @@ const parseMorphoResults = (
       loanAssetDecimals,
       collateralAssetDecimals,
     } = details
+
     const oracleId =
       ASSET_META[chainId][loanAsset]?.assetGroup ?? chainId + '-' + loanAsset
     const debtPrice = donePrices[oracleId]
@@ -428,8 +441,6 @@ const parseMorphoResults = (
       ASSET_META[chainId][collateralAsset]?.assetGroup ??
       chainId + '-' + collateralAsset
     const collateralPrice = donePrices[oracleIdCollateral]
-    console.log('debtPrice', oracleId, debtPrice)
-    console.log('collateralPrice', oracleIdCollateral, collateralPrice)
     const priceDebtToCollateral = formatMorphoPrice(
       d.toString(),
       loanAssetDecimals,

package/src/yields/index.ts

@@ -151,7 +151,7 @@ export const fetchGeneralYields = async () => {
     const res = await fetch(FeedData.HYPE).then((r) => r.json())
     return {
       [wstHype]: res.wstHYPE.latestApr,
-      [hyUSD]: res.kHYPE.latestApr,
+      [kHYPE]: res.kHYPE.latestApr,
     }
   })
 

package/test/lenderData.test.ts

@@ -16,8 +16,8 @@ import { prettyPrint } from './utils'
 describe(
   'find lending data',
   () => {
-    it('should return lender data', async () => {
-      const chainId = Chain.HYPEREVM
+    it.only('should return lender data', async () => {
+      const chainId = Chain.ARBITRUM_ONE
 
       const ps = [
         fetchMainPrices([chainId], getEvmClient),
@@ -29,7 +29,7 @@ describe(
       // console.log("yields", yields)
       // console.log("prices", prices)
 
-      const lenders = [Lender.HYPERLEND] // getLendersForChain(chainId) as any
+      const lenders = getLendersForChain(chainId) as any
       console.log('lenders', lenders)
       const lendingData = await getLenderPublicData(
         chainId,

package/test/mainPrices.test.ts

@@ -15,8 +15,8 @@ describe(
           // Chain.OP_MAINNET,
           // Chain.POLYGON_MAINNET,
           // Chain.HEMI_NETWORK,
-          Chain.ARBITRUM_ONE,
-          Chain.HYPEREVM,
+          // Chain.ARBITRUM_ONE,
+          // Chain.HYPEREVM,
           Chain.KATANA,
         ],
         getEvmClient,

package/test/userDataCompound.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import {
+  getLenderUserDataResult,
+  convertLenderUserDataResult,
+} from '../src/lending/user-data/fetchUserData'
+import {
+  fetchGeneralYields,
+  fetchMainPrices,
+  getLenderPublicData,
+} from '../src'
+import { multicallRetry, getEvmClient } from '@1delta/providers'
+import { Chain, Lender } from '@1delta/asset-registry'
+import { LenderUserQuery } from '../src/lending/user-data/types'
+import { getLendersForChain } from '../src/utils'
+import { prettyPrint } from './utils'
+
+const TEST_ADDRESS = '0xbadA9c382165b31419F4CC0eDf0Fa84f80A3C8E5'
+let prices, yields
+
+async function getUserData(chainId: Chain, lenders: Lender[]) {
+  const _lenders = getLendersForChain(chainId)
+  const publicData = {
+    data: await getLenderPublicData(
+      chainId,
+      _lenders as any,
+      prices as any,
+      yields as any,
+      multicallRetry,
+    ),
+  }
+
+  // Define user queries
+  const queries: LenderUserQuery[] = lenders.map((lender) => ({
+    lender,
+    account: TEST_ADDRESS.toLowerCase(),
+  }))
+
+  // Fetch raw user data
+  const rawUserData = await getLenderUserDataResult(
+    chainId,
+    queries,
+    getEvmClient,
+  )
+
+  // Convert raw data to structured format
+  const userData = convertLenderUserDataResult(
+    chainId,
+    queries,
+    rawUserData,
+    prices as any,
+    prices as any,
+    { [chainId]: publicData },
+  )
+
+  return { userData, rawUserData, publicData, queries }
+}
+
+describe(
+  'user data fetching',
+  () => {
+    beforeAll(async () => {
+      ;[prices, yields] = await Promise.all([
+        fetchMainPrices([Chain.ARBITRUM_ONE], getEvmClient),
+        fetchGeneralYields(),
+      ])
+    }, 30000)
+
+    it(
+      'should fetch user data for COMET on Arb',
+      async () => {
+        try {
+          const { userData } = await getUserData(Chain.ARBITRUM_ONE, [
+            Lender.COMPOUND_V3_USDC,
+          ])
+
+          console.log(
+            'COMET user data:',
+            userData[Lender.COMPOUND_V3_USDC]?.[TEST_ADDRESS.toLowerCase()],
+          )
+
+          prettyPrint(
+            userData[Lender.COMPOUND_V3_USDC]?.[TEST_ADDRESS.toLowerCase()],
+          )
+
+          // Basic validation
+          expect(userData).toBeDefined()
+          expect(typeof userData).toBe('object')
+        } catch (error) {
+          console.log('Error fetching INIT Mantle data:', error)
+        }
+      },
+      { timeout: 30000 },
+    )
+  },
+  { timeout: 90000 },
+)