@1delta/margin-fetcher 0.0.31 → 0.0.33

package/dist/lending/user-data/aave-v2-type/userCallParse.js

@@ -1,14 +1,13 @@
-import { Lender } from "@1delta/asset-registry";
-import { getAaveAssets, getAssetMeta, toGenericPriceKey, toOracleKey } from "../../../assets";
-import { AaveV2TypeGetUserReserveData } from "../types";
-import { AURELIUS_REWARD_ASSETS } from "../../aave-v2-type/misc";
-import { getLenderAssets } from "../../../utils";
-import { createBaseTypeUserState } from "../utils";
-import { parseRawAmount } from "../../../utils/parsing";
+import { Lender } from '@1delta/lender-registry';
+import { toGenericPriceKey, toOracleKey } from '../../../assets';
+import { AaveV2TypeGetUserReserveData, } from '../types';
+import { AURELIUS_REWARD_ASSETS } from '../../aave-v2-type/misc';
+import { createBaseTypeUserState } from '../utils';
+import { parseRawAmount } from '../../../utils/parsing';
 export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pricesHist, lenderData) => {
     switch (lender) {
         case Lender.AURELIUS: {
-            const assetsToQuery = getAaveAssets(chainId, lender);
+            const assetsToQuery = Object.keys(lenderData);
             const expectedNumberOfCalls = assetsToQuery.length + 1;
             return [
                 (data) => {
@@ -20,7 +19,7 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                     let totalDeposits24h = 0;
                     for (let i = 0; i < assetsToQuery.length; i++) {
                         const asset = assetsToQuery[i];
-                        const { dataForAsset, addedDebt, addedDeposits } = createAaveV2Entry(i, data, chainId, asset, prices, pricesHist, 0);
+                        const { dataForAsset, addedDebt, addedDeposits } = createAaveV2Entry(i, data, chainId, lenderData[asset].asset, prices, pricesHist, 0);
                         if (!dataForAsset)
                             continue;
                         totalDebt24h += addedDebt;
@@ -28,21 +27,24 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                         lendingPositions[asset] = dataForAsset;
                     }
                     const startIndex = assetsToQuery.length;
-                    const rewardMapping = Object.fromEntries(data[startIndex][0].map((key, index) => [key.toLowerCase(), data[startIndex][1][index]]));
+                    const rewardMapping = Object.fromEntries(data[startIndex][0].map((key, index) => [
+                        key.toLowerCase(),
+                        data[startIndex][1][index],
+                    ]));
                     const rewards = {};
                     for (let i = 0; i < AURELIUS_REWARD_ASSETS.length; i++) {
                         const asset = AURELIUS_REWARD_ASSETS[i];
                         const reward = Number(parseRawAmount(rewardMapping[asset.address.toLowerCase()].toString(), asset.decimals));
                         rewards[asset.symbol] = {
                             totalRewards: reward,
-                            claimableRewards: reward
+                            claimableRewards: reward,
                         };
                     }
                     const payload = {
                         chainId,
                         account,
-                        lendingPositions: { "0": lendingPositions },
-                        rewards
+                        lendingPositions: { '0': lendingPositions },
+                        rewards,
                     };
                     const userData = createBaseTypeUserState(payload, lenderData, totalDeposits24h, totalDebt24h);
                     return {
@@ -54,7 +56,7 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
             ];
         }
         case Lender.LENDLE: {
-            const assetsToQuery = getAaveAssets(chainId, lender);
+            const assetsToQuery = Object.keys(lenderData);
             const expectedNumberOfCalls = assetsToQuery.length + 2;
             return [
                 (data) => {
@@ -67,7 +69,7 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                     const mappedClaimableRewardsToTokens = assetsToQuery.map((name, index) => {
                         return {
                             [name]: Number(parseRawAmount(claimableRewards?.[index * 2]?.toString(), 18)) +
-                                Number(parseRawAmount(claimableRewards?.[index * 2 + 1]?.toString(), 18))
+                                Number(parseRawAmount(claimableRewards?.[index * 2 + 1]?.toString(), 18)),
                         };
                     });
                     const lendingPositions = {};
@@ -77,7 +79,7 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                     for (let i = 0; i < assetsToQuery.length; i++) {
                         const asset = assetsToQuery[i];
                         totalClaimableLend += mappedClaimableRewardsToTokens[i][asset];
-                        const { dataForAsset, addedDebt, addedDeposits } = createAaveV2Entry(i, data, chainId, asset, prices, pricesHist, mappedClaimableRewardsToTokens[i][asset]);
+                        const { dataForAsset, addedDebt, addedDeposits } = createAaveV2Entry(i, data, chainId, lenderData[asset].asset, prices, pricesHist, mappedClaimableRewardsToTokens[i][asset]);
                         if (!dataForAsset)
                             continue;
                         totalDebt24h += addedDebt;
@@ -87,12 +89,15 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                     const rewards = {};
                     const earnedBalances = data[expectedNumberOfCalls - 1];
                     const lendRewards = Number(parseRawAmount(earnedBalances[0].toString(), 18));
-                    rewards["LEND"] = { totalRewards: lendRewards + totalClaimableLend, claimableRewards: totalClaimableLend };
+                    rewards['LEND'] = {
+                        totalRewards: lendRewards + totalClaimableLend,
+                        claimableRewards: totalClaimableLend,
+                    };
                     const payload = {
                         chainId,
                         account,
-                        lendingPositions: { "0": lendingPositions },
-                        rewards
+                        lendingPositions: { '0': lendingPositions },
+                        rewards,
                     };
                     const userData = createBaseTypeUserState(payload, lenderData, totalDeposits24h, totalDebt24h);
                     return {
@@ -104,7 +109,7 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
             ];
         }
         case Lender.MERIDIAN: {
-            const assetsToQuery = getLenderAssets(chainId, lender);
+            const assetsToQuery = Object.keys(lenderData);
             const expectedNumberOfCalls = assetsToQuery.length + 2;
             return [
                 (data) => {
@@ -118,8 +123,8 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                     // foreach asset, we sum the l and v token rewards from the rewards balance array
                     const mappedClaimableRewardsToTokens = assetsToQuery.map((name, index) => {
                         return {
-                            [name]: Number(parseRawAmount(rewardsBalanceArray[index * 2]?.toString() || "0", 18)) +
-                                Number(parseRawAmount(rewardsBalanceArray[index * 2 + 1]?.toString() || "0", 18))
+                            [name]: Number(parseRawAmount(rewardsBalanceArray[index * 2]?.toString() || '0', 18)) +
+                                Number(parseRawAmount(rewardsBalanceArray[index * 2 + 1]?.toString() || '0', 18)),
                         };
                     });
                     const lendingPositions = {};
@@ -130,7 +135,7 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                         const asset = assetsToQuery[i];
                         const assetClaimableRewards = mappedClaimableRewardsToTokens[i][asset];
                         totalClaimableRewards += assetClaimableRewards;
-                        const { dataForAsset, addedDebt, addedDeposits } = createAaveV2Entry(i, data, chainId, asset, prices, pricesHist, assetClaimableRewards);
+                        const { dataForAsset, addedDebt, addedDeposits } = createAaveV2Entry(i, data, chainId, lenderData[asset].asset, prices, pricesHist, assetClaimableRewards);
                         if (!dataForAsset)
                             continue;
                         totalDebt24h += addedDebt;
@@ -138,15 +143,15 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                         lendingPositions[asset] = dataForAsset;
                     }
                     const rewards = {};
-                    rewards["TAIKO"] = {
+                    rewards['TAIKO'] = {
                         totalRewards,
-                        claimableRewards: totalClaimableRewards
+                        claimableRewards: totalClaimableRewards,
                     };
                     const payload = {
                         chainId,
                         account,
-                        lendingPositions: { "0": lendingPositions },
-                        rewards
+                        lendingPositions: { '0': lendingPositions },
+                        rewards,
                     };
                     const userData = createBaseTypeUserState(payload, lenderData, totalDeposits24h, totalDebt24h);
                     return {
@@ -158,7 +163,7 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
             ];
         }
         default: {
-            const assetsToQuery = getLenderAssets(chainId, lender);
+            const assetsToQuery = Object.keys(lenderData);
             const expectedNumberOfCalls = assetsToQuery.length;
             return [
                 (data) => {
@@ -170,7 +175,7 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                     let totalDeposits24h = 0;
                     for (let i = 0; i < assetsToQuery.length; i++) {
                         const asset = assetsToQuery[i];
-                        const { dataForAsset, addedDebt, addedDeposits } = createAaveV2Entry(i, data, chainId, asset, prices, pricesHist, 0);
+                        const { dataForAsset, addedDebt, addedDeposits } = createAaveV2Entry(i, data, chainId, lenderData[asset].asset, prices, pricesHist, 0);
                         if (!dataForAsset)
                             continue;
                         totalDebt24h += addedDebt;
@@ -180,8 +185,8 @@ export const getAaveV2UserDataConverter = (lender, chainId, account, prices, pri
                     const payload = {
                         chainId,
                         account,
-                        lendingPositions: { "0": lendingPositions },
-                        rewards: {}
+                        lendingPositions: { '0': lendingPositions },
+                        rewards: {},
                     };
                     const userData = createBaseTypeUserState(payload, lenderData, totalDeposits24h, totalDebt24h);
                     return {
@@ -199,21 +204,22 @@ function createAaveV2Entry(i, data, chainId, asset, prices, pricesHist, claimabl
     const currentATokenBalanceRaw = reserveData[AaveV2TypeGetUserReserveData.currentATokenBalance]?.toString();
     const currentStableDebtRaw = reserveData[AaveV2TypeGetUserReserveData.currentStableDebt]?.toString();
     const currentVariableDebtRaw = reserveData[AaveV2TypeGetUserReserveData.currentVariableDebt]?.toString();
-    if (currentATokenBalanceRaw === "0" &&
-        currentStableDebtRaw === "0" &&
-        currentVariableDebtRaw === "0") {
+    if (currentATokenBalanceRaw === '0' &&
+        currentStableDebtRaw === '0' &&
+        currentVariableDebtRaw === '0') {
         return {
             dataForAsset: undefined,
             addedDeposits: 0,
-            addedDebt: 0
+            addedDebt: 0,
         };
     }
-    const assetMeta = getAssetMeta(chainId, asset);
+    const assetMeta = asset;
     const decimals = assetMeta?.decimals ?? 18;
     const currentATokenBalance = parseRawAmount(currentATokenBalanceRaw, decimals);
     const currentStableDebt = parseRawAmount(currentStableDebtRaw, decimals);
     const currentVariableDebt = parseRawAmount(currentVariableDebtRaw, decimals);
-    const key = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(asset, chainId);
+    const key = toOracleKey(assetMeta?.assetGroup) ??
+        toGenericPriceKey(asset.address, chainId);
     const price = prices[key] ?? 1;
     const priceHist = pricesHist?.[key] ?? price;
     const dataForAsset = {
@@ -233,6 +239,6 @@ function createAaveV2Entry(i, data, chainId, asset, prices, pricesHist, claimabl
     return {
         dataForAsset,
         addedDeposits: Number(currentATokenBalance) * priceHist,
-        addedDebt: (Number(currentVariableDebt) + Number(currentStableDebt)) * priceHist
+        addedDebt: (Number(currentVariableDebt) + Number(currentStableDebt)) * priceHist,
     };
 }

package/dist/lending/user-data/aave-v3-type/userCallBuild.d.ts

@@ -1,4 +1,4 @@
-import { Lender } from "@1delta/asset-registry";
+import { Lender } from '@1delta/lender-registry';
 import { Call } from "../../../utils/multicall";
 export declare const buildAaveV3UserCall: (chainId: string, lender: Lender, account: string) => Call[];
 //# sourceMappingURL=userCallBuild.d.ts.map

package/dist/lending/user-data/aave-v3-type/userCallBuild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userCallBuild.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/aave-v3-type/userCallBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AAmB/C,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,EAAE,SAAS,MAAM,KAAG,IAAI,EAqB1F,CAAA"}
+{"version":3,"file":"userCallBuild.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/aave-v3-type/userCallBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AAmB/C,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,EAAE,SAAS,MAAM,KAAG,IAAI,EAqB1F,CAAA"}

package/dist/lending/user-data/aave-v3-type/userCallParse.d.ts

@@ -1,4 +1,4 @@
-import { Lender } from '@1delta/asset-registry';
+import { Lender } from '@1delta/lender-registry';
 import { AaveV3UserReserveResponse } from '../types';
 export declare const getAaveV3UserDataConverter: (lender: Lender, chainId: string, account: string, prices: {
     [asset: string]: number;

package/dist/lending/user-data/aave-v3-type/userCallParse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userCallParse.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/aave-v3-type/userCallParse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAO/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAKpD,eAAO,MAAM,0BAA0B,GACrC,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACnC,YAAY;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACvC,YAAY,GAAG,KACd,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,yBAAyB,GAAG,SAAS,EAAE,MAAM,CAqDjE,CAAA"}
+{"version":3,"file":"userCallParse.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/aave-v3-type/userCallParse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAKhD,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAMpD,eAAO,MAAM,0BAA0B,GACrC,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACnC,YAAY;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACvC,YAAY,GAAG,KACd,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,yBAAyB,GAAG,SAAS,EAAE,MAAM,CAqDjE,CAAA"}

package/dist/lending/user-data/aave-v3-type/userCallParse.js

@@ -1,9 +1,9 @@
-import { getAaveAssets, getAssetMeta, toGenericPriceKey, toOracleKey, } from '../../../assets';
+import { toGenericPriceKey, toOracleKey, } from '../../../assets';
 import { createBaseTypeUserState } from '../utils';
 import { AaveTypeGetUserReserveIndexes } from '../../aave-v3-type/types';
 import { parseRawAmount } from '../../../utils/parsing';
 export const getAaveV3UserDataConverter = (lender, chainId, account, prices, pricesHist, lenderData) => {
-    const assetsToQuery = getAaveAssets(chainId, lender);
+    const assetsToQuery = Object.keys(lenderData);
     const expectedNumberOfCalls = assetsToQuery.length + 1;
     return [
         (data) => {
@@ -16,7 +16,7 @@ export const getAaveV3UserDataConverter = (lender, chainId, account, prices, pri
             let totalDeposits24h = 0;
             for (let i = 0; i < assetsToQuery.length; i++) {
                 const asset = assetsToQuery[i];
-                const { dataForAsset, addedDebt, addedDeposits } = createAaveV3Entry(i, data, chainId, asset, prices, pricesHist);
+                const { dataForAsset, addedDebt, addedDeposits } = createAaveV3Entry(i, data, chainId, lenderData[asset].asset, prices, pricesHist);
                 if (!dataForAsset)
                     continue;
                 totalDebt24h += addedDebt;
@@ -53,12 +53,12 @@ function createAaveV3Entry(i, data, chainId, asset, prices, pricesHist) {
             addedDebt: 0,
         };
     }
-    const assetMeta = getAssetMeta(chainId, asset);
+    const assetMeta = asset;
     const decimals = assetMeta?.decimals ?? 18;
     const currentATokenBalance = parseRawAmount(currentATokenBalanceRaw, decimals);
     const currentStableDebt = parseRawAmount(currentStableDebtRaw, decimals);
     const currentVariableDebt = parseRawAmount(currentVariableDebtRaw, decimals);
-    const key = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(asset, chainId);
+    const key = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(asset.address, chainId);
     // prices
     const price = prices[key] ?? 1;
     const priceHist = pricesHist?.[key] ?? price;

package/dist/lending/user-data/aave-v3-type/userCallParseYldr.d.ts

@@ -1,5 +1,5 @@
-import { Lender } from "@1delta/asset-registry";
-import { AaveV3UserReserveResponse } from "../types";
+import { Lender } from '@1delta/lender-registry';
+import { AaveV3UserReserveResponse } from '../types';
 /** Like Aave V3, not stable debt data and no emode */
 export declare const getYldrUserDataConverter: (lender: Lender, chainId: string, account: string, prices: {
     [asset: string]: number;

package/dist/lending/user-data/aave-v3-type/userCallParseYldr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userCallParseYldr.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/aave-v3-type/userCallParseYldr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAE/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAKpD,sDAAsD;AACtD,eAAO,MAAM,wBAAwB,GACnC,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACnC,YAAY;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACvC,YAAY,GAAG,KACd,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,yBAAyB,GAAG,SAAS,EAAE,MAAM,CAkDjE,CAAA"}
+{"version":3,"file":"userCallParseYldr.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/aave-v3-type/userCallParseYldr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAEhD,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAMpD,sDAAsD;AACtD,eAAO,MAAM,wBAAwB,GACnC,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACnC,YAAY;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACvC,YAAY,GAAG,KACd,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,yBAAyB,GAAG,SAAS,EAAE,MAAM,CAkDjE,CAAA"}

package/dist/lending/user-data/aave-v3-type/userCallParseYldr.js

@@ -1,10 +1,10 @@
-import { getAaveAssets, getAssetMeta, toGenericPriceKey, toOracleKey } from "../../../assets";
-import { createBaseTypeUserState } from "../utils";
-import { YldrTypeGetUserReserveIndexes } from "../../aave-v3-type/types";
-import { parseRawAmount } from "../../../utils/parsing";
+import { toGenericPriceKey, toOracleKey } from '../../../assets';
+import { createBaseTypeUserState } from '../utils';
+import { YldrTypeGetUserReserveIndexes } from '../../aave-v3-type/types';
+import { parseRawAmount } from '../../../utils/parsing';
 /** Like Aave V3, not stable debt data and no emode */
 export const getYldrUserDataConverter = (lender, chainId, account, prices, pricesHist, lenderData) => {
-    const assetsToQuery = getAaveAssets(chainId, lender);
+    const assetsToQuery = Object.keys(lenderData);
     const expectedNumberOfCalls = assetsToQuery.length;
     return [
         (data) => {
@@ -16,7 +16,7 @@ export const getYldrUserDataConverter = (lender, chainId, account, prices, price
             let totalDeposits24h = 0;
             for (let i = 0; i < assetsToQuery.length; i++) {
                 const asset = assetsToQuery[i];
-                const { dataForAsset, addedDebt, addedDeposits } = createAaveV3Entry(i, data, chainId, asset, prices, pricesHist);
+                const { dataForAsset, addedDebt, addedDeposits } = createAaveV3Entry(i, data, chainId, lenderData[asset].asset ``, prices, pricesHist);
                 if (!dataForAsset)
                     continue;
                 totalDebt24h += addedDebt;
@@ -26,14 +26,14 @@ export const getYldrUserDataConverter = (lender, chainId, account, prices, price
             const payload = {
                 chainId,
                 account,
-                lendingPositions: { "0": lendingPositions },
+                lendingPositions: { '0': lendingPositions },
                 rewards: {},
                 userEMode: 0,
             };
             const userData = createBaseTypeUserState(payload, lenderData, totalDeposits24h, totalDebt24h);
             return {
                 ...payload,
-                ...userData
+                ...userData,
             };
         },
         expectedNumberOfCalls,
@@ -43,19 +43,19 @@ function createAaveV3Entry(i, data, chainId, asset, prices, pricesHist) {
     const reserveData = data[i];
     const currentATokenBalanceRaw = reserveData[YldrTypeGetUserReserveIndexes.currentYTokenBalance]?.toString();
     const currentVariableDebtRaw = reserveData[YldrTypeGetUserReserveIndexes.currentVariableDebt]?.toString();
-    if (currentATokenBalanceRaw === "0" &&
-        currentVariableDebtRaw === "0") {
+    if (currentATokenBalanceRaw === '0' && currentVariableDebtRaw === '0') {
         return {
             dataForAsset: undefined,
             addedDeposits: 0,
-            addedDebt: 0
+            addedDebt: 0,
         };
     }
-    const assetMeta = getAssetMeta(chainId, asset);
+    const assetMeta = asset;
     const decimals = assetMeta?.decimals ?? 18;
     const currentATokenBalance = parseRawAmount(currentATokenBalanceRaw, decimals);
     const currentVariableDebt = parseRawAmount(currentVariableDebtRaw, decimals);
-    const key = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(asset, chainId);
+    const key = toOracleKey(assetMeta?.assetGroup) ??
+        toGenericPriceKey(asset.address, chainId);
     // prices
     const price = prices[key] ?? 1;
     const priceHist = pricesHist?.[key] ?? price;
@@ -64,7 +64,7 @@ function createAaveV3Entry(i, data, chainId, asset, prices, pricesHist) {
         underlying: asset,
         deposits: currentATokenBalance,
         depositsRaw: currentATokenBalanceRaw,
-        debtStable: "0",
+        debtStable: '0',
         debt: currentVariableDebt,
         depositsUSD: Number(currentATokenBalance) * price,
         debtStableUSD: 0,
@@ -76,6 +76,6 @@ function createAaveV3Entry(i, data, chainId, asset, prices, pricesHist) {
     return {
         dataForAsset,
         addedDeposits: Number(currentATokenBalance) * priceHist,
-        addedDebt: Number(currentVariableDebt) * priceHist
+        addedDebt: Number(currentVariableDebt) * priceHist,
     };
 }

package/dist/lending/user-data/abis.d.ts

@@ -1,4 +1,4 @@
-import { Lender } from "@1delta/asset-registry";
+import { Lender } from '@1delta/lender-registry';
 export declare const getAbi: (lender: Lender) => readonly [{
     readonly inputs: readonly [{
         readonly internalType: "uint16";

package/dist/lending/user-data/abis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abis.d.ts","sourceRoot":"","sources":["../../../src/lending/user-data/abis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAoB/C,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgCpC,CAAA"}
+{"version":3,"file":"abis.d.ts","sourceRoot":"","sources":["../../../src/lending/user-data/abis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAoBhD,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgCpC,CAAA"}

package/dist/lending/user-data/compound-v3/userCallBuild.d.ts

@@ -1,4 +1,4 @@
-import { Lender } from '@1delta/asset-registry';
+import { Lender } from '@1delta/lender-registry';
 import { Call } from '../../../utils/multicall';
 export declare const buildCompoundV3UserCall: (chainId: string, lender: Lender, account: string) => Call[];
 //# sourceMappingURL=userCallBuild.d.ts.map

package/dist/lending/user-data/compound-v3/userCallBuild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userCallBuild.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/compound-v3/userCallBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AAQ/C,eAAO,MAAM,uBAAuB,GAClC,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,SAAS,MAAM,KACd,IAAI,EAkCN,CAAA"}
+{"version":3,"file":"userCallBuild.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/compound-v3/userCallBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AAQ/C,eAAO,MAAM,uBAAuB,GAClC,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,SAAS,MAAM,KACd,IAAI,EAkCN,CAAA"}

package/dist/lending/user-data/compound-v3/userCallParse.d.ts

@@ -1,4 +1,4 @@
-import { Lender } from '@1delta/asset-registry';
+import { Lender } from '@1delta/lender-registry';
 import { CompoundV3UserReserveResponse } from '../types';
 export declare const getCompoundV3UserDataConverter: (lender: Lender, chainId: string, account: string, prices: {
     [asset: string]: number;

package/dist/lending/user-data/compound-v3/userCallParse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userCallParse.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/compound-v3/userCallParse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAA;AAWxD,eAAO,MAAM,8BAA8B,GACzC,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACnC,YAAY;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACvC,YAAY,GAAG,KACd,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,6BAA6B,GAAG,SAAS,EAAE,MAAM,CAmHrE,CAAA"}
+{"version":3,"file":"userCallParse.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/compound-v3/userCallParse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAChD,OAAO,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAA;AASxD,eAAO,MAAM,8BAA8B,GACzC,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACnC,YAAY;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACvC,YAAY,GAAG,KACd,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,6BAA6B,GAAG,SAAS,EAAE,MAAM,CAmHrE,CAAA"}

package/dist/lending/user-data/compound-v3/userCallParse.js

@@ -1,9 +1,9 @@
-import { getAssetMeta, getCompoundV3Assets, toGenericPriceKey, toOracleKey, } from '../../../assets';
+import { toGenericPriceKey, toOracleKey, } from '../../../assets';
 import { getCompoundV3BaseAsset } from '../../addresses/compoundV3';
 import { parseRawAmount } from '../../../utils/parsing';
 import { createBaseTypeUserState } from '../utils';
 export const getCompoundV3UserDataConverter = (lender, chainId, account, prices, pricesHist, lenderData) => {
-    const assetAddresses = getCompoundV3Assets(chainId, lender);
+    const assetAddresses = Object.keys(lenderData);
     const baseAsset = getCompoundV3BaseAsset(lender, chainId)?.baseAsset;
     const assetsNoBase = assetAddresses.filter((a) => a !== baseAsset);
     const expectedNumberOfCalls = assetsNoBase.length + 2 + 1;
@@ -17,7 +17,7 @@ export const getCompoundV3UserDataConverter = (lender, chainId, account, prices,
             let result = {};
             for (let i = 0; i < assetsNoBase.length; i++) {
                 const asset = assetsNoBase[i];
-                const assetMeta = getAssetMeta(chainId, asset);
+                const assetMeta = lenderData[asset].asset;
                 const decimals = assetMeta?.decimals ?? 18;
                 const depositsRaw = data[i][0]?.toString();
                 if (depositsRaw === '0')
@@ -46,7 +46,7 @@ export const getCompoundV3UserDataConverter = (lender, chainId, account, prices,
             }
             const depositsRaw = data[assetsNoBase.length]?.toString();
             const debtRaw = data[assetsNoBase.length + 1]?.toString();
-            const baseMeta = getAssetMeta(chainId, baseAsset);
+            const baseMeta = lenderData[baseAsset].asset;
             const baseDecimals = baseMeta.decimals ?? 18;
             const deposits = parseRawAmount(depositsRaw, baseDecimals);
             const debt = parseRawAmount(debtRaw, baseDecimals);

package/dist/lending/user-data/init/userCallBuild.d.ts

@@ -1,5 +1,5 @@
-import { Lender } from "@1delta/asset-registry";
-import { Call } from "../../../utils/multicall";
+import { Lender } from '@1delta/lender-registry';
+import { Call } from '../../../utils/multicall';
 export declare const initBrokerAddresses: {
     "5000": string;
 };

package/dist/lending/user-data/init/userCallBuild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userCallBuild.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/init/userCallBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,wBAAwB,CAAA;AACtD,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AAG/C,eAAO,MAAM,mBAAmB;;CAE/B,CAAA;AAED,wBAAgB,6BAA6B,CAAC,OAAO,CAAC,EAAE,MAAM,sBAG7D;AAED,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,EAAE,SAAS,MAAM,KAAG,IAAI,EAYxF,CAAA"}
+{"version":3,"file":"userCallBuild.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/init/userCallBuild.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AAG/C,eAAO,MAAM,mBAAmB;;CAE/B,CAAA;AAED,wBAAgB,6BAA6B,CAAC,OAAO,CAAC,EAAE,MAAM,sBAG7D;AAED,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,SAAS,MAAM,KACd,IAAI,EAWN,CAAA"}

package/dist/lending/user-data/init/userCallBuild.js

@@ -1,7 +1,7 @@
-import { Chain } from "@1delta/asset-registry";
-import { getInitLensAddress } from "../../addresses/init";
+import { Chain } from '@1delta/chain-registry';
+import { getInitLensAddress } from '../../addresses/init';
 export const initBrokerAddresses = {
-    [Chain.MANTLE]: '0xc08BFef7E778f3519D79E96780b77066F5d4FCC0'
+    [Chain.MANTLE]: '0xc08BFef7E778f3519D79E96780b77066F5d4FCC0',
 };
 export function getInitFlashAggregatorAddress(chainId) {
     if (!chainId)

package/dist/lending/user-data/init/userCallParse.d.ts

@@ -1,4 +1,4 @@
-import { Lender } from "@1delta/asset-registry";
+import { Lender } from '@1delta/lender-registry';
 import { InitUserReserveResponse } from "../types";
 export declare const getInitUserDataConverter: (lender: Lender, chainId: string, account: string, prices: {
     [asset: string]: number;

package/dist/lending/user-data/init/userCallParse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userCallParse.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/init/userCallParse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAQlD,eAAO,MAAM,wBAAwB,GACnC,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACnC,YAAY;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACvC,YAAY,GAAG,KACd,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,uBAAuB,GAAG,SAAS,EAAE,MAAM,CAkG/D,CAAA"}
+{"version":3,"file":"userCallParse.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/init/userCallParse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAChD,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAQlD,eAAO,MAAM,wBAAwB,GACnC,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACnC,YAAY;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACvC,YAAY,GAAG,KACd,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,uBAAuB,GAAG,SAAS,EAAE,MAAM,CAkG/D,CAAA"}

package/dist/lending/user-data/init/userCallParse.js

@@ -1,7 +1,7 @@
 import { getInitFlashAggregatorAddress } from "./userCallBuild";
 import { InitGetUserPositionDataIndexes } from "../../init/types";
 import { getLenderAssets } from "../../../utils";
-import { getAssetMeta, toOracleKey } from "../../../assets";
+import { toOracleKey } from "../../../assets";
 import { parseRawAmount } from "../../../utils/parsing";
 import { createMultiAccountTypeUserState } from "../utils/createMultiAccountStyleUserState";
 export const getInitUserDataConverter = (lender, chainId, account, prices, pricesHist, lenderData) => {
@@ -25,13 +25,13 @@ export const getInitUserDataConverter = (lender, chainId, account, prices, price
                 const id = entry.posId.toString();
                 const collatData = Object.assign({}, ...data[InitGetUserPositionDataIndexes.collaterals][index].map((c) => {
                     const asset = c.underlying.toLowerCase();
-                    const decimals = getAssetMeta(chainId, asset)?.decimals ?? 18;
+                    const decimals = lenderData[asset].asset?.decimals ?? 18;
                     const depositsRaw = c.amount.toString();
                     return { [asset]: { deposits: parseRawAmount(depositsRaw, decimals), depositsRaw } };
                 }));
                 const debtData = Object.assign({}, ...data[InitGetUserPositionDataIndexes.debts][index].map((c) => {
                     const asset = c.underlying.toLowerCase();
-                    const decimals = getAssetMeta(chainId, asset)?.decimals ?? 18;
+                    const decimals = lenderData[asset]?.asset?.decimals ?? 18;
                     return { [asset]: { debt: parseRawAmount(c.amount.toString(), decimals) } };
                 }));
                 // sub account to asset data
@@ -39,7 +39,7 @@ export const getInitUserDataConverter = (lender, chainId, account, prices, price
                     [id]: {
                         mode,
                         ...Object.assign({}, ...assets.map(a => {
-                            const ams = toOracleKey(getAssetMeta(chainId, a)?.assetGroup);
+                            const ams = toOracleKey(lenderData[a]?.asset?.assetGroup);
                             const price = prices[ams] ?? 1;
                             const priceHist = pricesHist?.[ams] ?? price;
                             if (!histData[id])

package/dist/lending/user-data/morpho/userCallBuild.d.ts

@@ -1,4 +1,4 @@
-import { Lender } from '@1delta/asset-registry';
+import { Lender } from '@1delta/lender-registry';
 import { Call } from '../../../utils/multicall';
 export declare const buildMorphoUserCall: (chainId: string, account: string, lender: Lender, marketsToQuery: string[]) => Call[];
 export declare const buildMorphoUserCallWithLens: (chainId: string, account: string, lender: Lender, marketsToQuery: string[]) => Call[];

package/dist/lending/user-data/morpho/userCallBuild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userCallBuild.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/morpho/userCallBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAyB,MAAM,wBAAwB,CAAA;AAC7E,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AAmC/C,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,gBAAgB,MAAM,EAAE,KACvB,IAAI,EAIN,CAAA;AAED,eAAO,MAAM,2BAA2B,GACtC,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,gBAAgB,MAAM,EAAE,KACvB,IAAI,EAaN,CAAA"}
+{"version":3,"file":"userCallBuild.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/morpho/userCallBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAEhD,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AAqC/C,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,gBAAgB,MAAM,EAAE,KACvB,IAAI,EAIN,CAAA;AAED,eAAO,MAAM,2BAA2B,GACtC,SAAS,MAAM,EACf,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,gBAAgB,MAAM,EAAE,KACvB,IAAI,EAaN,CAAA"}

package/dist/lending/user-data/morpho/userCallBuild.js

@@ -1,5 +1,6 @@
-import { Chain, MORPHO_BLUE_POOL_DATA } from '@1delta/asset-registry';
+import { Chain } from '@1delta/chain-registry';
 import { chunk } from 'lodash';
+import { morphoPools } from '@1delta/data-sdk';
 const MORPHO_LENS = {
     [Chain.BASE]: '0x98542B95B44a4732EffB1F4F01A696F1546236d3',
     [Chain.POLYGON_MAINNET]: '0x105eb87D2b3127f43B1b4C0F125dbEb0EDF3d6C6',
@@ -10,16 +11,17 @@ const MORPHO_LENS = {
     [Chain.ETHEREUM_MAINNET]: '0x0bd7473CbBf81d9dD936c61117eD230d95006CA2',
 };
 const getBaseMorphoCalls = (lender, chainId, account, marketsToQuery) => {
+    const mbPool = morphoPools()?.[lender]?.[chainId];
     return marketsToQuery.flatMap((id) => [
         {
             // @ts-ignore
-            address: MORPHO_BLUE_POOL_DATA[lender][chainId],
+            address: mbPool,
             name: 'position',
             params: ['0x' + id.split('_')[1], account],
         },
         {
             // @ts-ignore
-            address: MORPHO_BLUE_POOL_DATA[lender][chainId],
+            address: mbPool,
             name: 'market',
             params: ['0x' + id.split('_')[1]],
         },
@@ -39,7 +41,7 @@ export const buildMorphoUserCallWithLens = (chainId, account, lender, marketsToQ
             marketsInChunk.map((a) => a.replace('MORPHO_BLUE_', '0x')),
             account,
             // @ts-ignore
-            MORPHO_BLUE_POOL_DATA[lender][chainId],
+            morphoPools()?.[lender]?.[chainId],
         ],
     }));
 };