@1delta/margin-fetcher 0.0.43 → 0.0.45

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

@@ -1 +0,0 @@
-{"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/abis.js

@@ -1,56 +0,0 @@
-import { isAaveV2Type, isAaveV3Type, isCompoundV3, isInit, isAaveV32Type, isYLDR, isMorphoType } from "../../utils";
-import { IncentivesControllerAbi } from "../../abis/lendle/IncentivesController";
-import { RewarderAbi } from "../../abis/aurelius/Rewarder";
-import { AavePoolV3UpgradedAbi } from "../../abis/aave/AavePoolV3Upgraded";
-import { AaveV3ProtocolDataProviderAbi } from "../../abis/aave/AaveV3ProtocolDataProvider";
-import { InitLensAbi } from "../../abis/init/InitLens";
-import { CometAbi } from "../../abis/compound-v3/Comet";
-import { CometExtAbi } from "../../abis/compound-v3/CometExt";
-import { AavePoolLegacyAbi } from "../../abis/aave-v3/AavePoolLegacy";
-import { AavePoolDataProviderLegacyAbi } from "../../abis/aave-v3/AavePoolDataProviderLegacy";
-import { AavePoolAndDataProviderAbi } from "../../abis/aave/AavePoolAndDataProvider";
-import { VariableDebtTokenAbi } from "../../abis/aave/VariableDebtToken";
-import { MultiFeeDistributionAbi } from "../../abis/lendle/MultiFeeDistribution";
-import { PullRewardsIncentivesController } from "../../abis/meridian/PullRewardsIncentivesController";
-import { CometRewardsAbi } from "../../abis/compound-v3/CometRewards";
-import { YLDRAbi } from "../../abis/aave-v3/YLDR";
-import { MorphoBlueAbi } from "../../abis/morpho/blue";
-import { MorphoLensAbi } from "../../abis/morpho/lens";
-export const getAbi = (lender) => {
-    if (isAaveV2Type(lender))
-        return [
-            ...AavePoolAndDataProviderAbi,
-            ...VariableDebtTokenAbi,
-            ...RewarderAbi,
-            ...PullRewardsIncentivesController,
-            ...IncentivesControllerAbi,
-            ...MultiFeeDistributionAbi
-        ];
-    if (isYLDR(lender))
-        return [
-            ...VariableDebtTokenAbi,
-            ...YLDRAbi
-        ];
-    if (isAaveV32Type(lender))
-        return [
-            ...AavePoolV3UpgradedAbi,
-            ...AaveV3ProtocolDataProviderAbi
-        ];
-    if (isAaveV3Type(lender))
-        return [
-            ...AavePoolLegacyAbi,
-            ...VariableDebtTokenAbi,
-            ...AavePoolDataProviderLegacyAbi
-        ];
-    if (isCompoundV3(lender))
-        return [
-            ...CometAbi,
-            ...CometExtAbi,
-            ...CometRewardsAbi,
-        ];
-    if (isMorphoType(lender))
-        return [...MorphoBlueAbi, ...MorphoLensAbi];
-    if (isInit(lender))
-        return InitLensAbi;
-    return [];
-};

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

@@ -1,3 +0,0 @@
-export * from "./userCallBuild";
-export * from "./userCallParse";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/compound-v3/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA"}

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

@@ -1,2 +0,0 @@
-export * from "./userCallBuild";
-export * from "./userCallParse";

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

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

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

@@ -1 +0,0 @@
-{"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,EACf,iBAAiB,MAAM,EAAE,KACxB,IAAI,EAkCN,CAAA"}

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

@@ -1,34 +0,0 @@
-import { getLenderAssets } from '../../../utils';
-import { getCompoundV3BaseAsset, getCompoundV3CometAddress, getCompoundV3CometRewardsAddress, } from '../../addresses/compoundV3';
-export const buildCompoundV3UserCall = (chainId, lender, account, assetsOverride) => {
-    const baseAsset = getCompoundV3BaseAsset(lender, chainId)?.baseAsset;
-    const cometContractAddress = getCompoundV3CometAddress(chainId, lender);
-    const assets = assetsOverride ?? getLenderAssets(chainId, lender);
-    const assetsNoBase = assets.filter((a) => a !== baseAsset);
-    const baseCalls = [
-        {
-            address: cometContractAddress,
-            name: 'balanceOf',
-            params: [account],
-        },
-        {
-            address: cometContractAddress,
-            name: 'borrowBalanceOf',
-            params: [account],
-        },
-    ];
-    const callsNonBase = assetsNoBase.map((tk) => {
-        return {
-            address: cometContractAddress,
-            name: 'userCollateral',
-            params: [account, tk],
-        };
-    });
-    const callEarnedBalances = {
-        address: getCompoundV3CometRewardsAddress(chainId),
-        name: 'getRewardOwed',
-        params: [cometContractAddress, account],
-    };
-    const calls = [...callsNonBase, ...baseCalls, callEarnedBalances];
-    return calls;
-};

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

@@ -1,8 +0,0 @@
-import { Lender } from '@1delta/lender-registry';
-import { CompoundV3UserReserveResponse } from '../types';
-export declare const getCompoundV3UserDataConverter: (lender: Lender, chainId: string, account: string, prices: {
-    [asset: string]: number;
-}, pricesHist: {
-    [asset: string]: number;
-}, lenderData: any) => [(data: any[]) => CompoundV3UserReserveResponse | undefined, number];
-//# sourceMappingURL=userCallParse.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AAMxD,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,CAkHrE,CAAA"}

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

@@ -1,101 +0,0 @@
-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 = Object.keys(lenderData);
-    const baseAsset = getCompoundV3BaseAsset(lender, chainId)?.baseAsset;
-    const assetsNoBase = assetAddresses.filter((a) => a !== baseAsset);
-    const expectedNumberOfCalls = assetsNoBase.length + 2 + 1;
-    return [
-        (data) => {
-            if (data.length !== expectedNumberOfCalls) {
-                return undefined;
-            }
-            let totalDebt24h = 0;
-            let totalDeposits24h = 0;
-            let result = {};
-            for (let i = 0; i < assetsNoBase.length; i++) {
-                const asset = assetsNoBase[i];
-                const assetMeta = lenderData[asset].asset;
-                const decimals = assetMeta?.decimals ?? 18;
-                const depositsRaw = data[i][0]?.toString();
-                if (depositsRaw === '0')
-                    continue;
-                const deposits = parseRawAmount(depositsRaw, decimals);
-                const key = toOracleKey(assetMeta?.assetGroup) ??
-                    toGenericPriceKey(asset, chainId);
-                const price = prices[key] ?? 1;
-                const priceHist = pricesHist?.[key] ?? price;
-                // accure
-                totalDeposits24h += Number(deposits) * priceHist;
-                result[asset] = {
-                    poolId: asset,
-                    underlying: asset,
-                    deposits,
-                    depositsUSD: Number(deposits) * price,
-                    debtStableUSD: 0,
-                    debt: '0',
-                    debtStable: '0',
-                    debtUSD: 0,
-                    collateralActive: true,
-                    // user depos raw
-                    depositsRaw,
-                    // flag for allowance
-                };
-            }
-            const depositsRaw = data[assetsNoBase.length]?.toString();
-            const debtRaw = data[assetsNoBase.length + 1]?.toString();
-            const baseMeta = lenderData[baseAsset].asset;
-            const baseDecimals = baseMeta.decimals ?? 18;
-            const deposits = parseRawAmount(depositsRaw, baseDecimals);
-            const debt = parseRawAmount(debtRaw, baseDecimals);
-            const oracleKeyBase = toOracleKey(baseMeta?.assetGroup) ??
-                toGenericPriceKey(baseMeta.baseAsset, chainId);
-            const priceBase = prices[oracleKeyBase];
-            const priceBaseHist = pricesHist?.[oracleKeyBase] ?? priceBase;
-            // accrue base data
-            totalDebt24h += Number(debt) * priceBaseHist;
-            totalDeposits24h += Number(deposits) * priceBaseHist;
-            const resultBase = {
-                [baseAsset]: {
-                    poolId: baseAsset,
-                    underlying: baseAsset,
-                    deposits,
-                    debt,
-                    depositsUSD: Number(deposits) * priceBase,
-                    debtUSD: Number(debt) * priceBase,
-                    // populate values for totals
-                    debtStable: '0',
-                    debtStableUSD: 0,
-                    collateralActive: true,
-                    // user depos raw
-                    depositsRaw,
-                    // flag for allowance
-                },
-            };
-            // the result is an array: [tokenAddress, owedAmount] (tokenAddress should be always COMP)
-            // so we take [1] to get the owedAmount
-            const earnedBalances = data[expectedNumberOfCalls - 1];
-            const compRewards = Number(parseRawAmount(earnedBalances?.owed?.toString(), 18));
-            const payload = {
-                lendingPositions: { [0]: { ...result, ...resultBase } },
-                chainId,
-                baseAsset,
-                rewards: {
-                    ['COMP']: {
-                        totalRewards: compRewards,
-                        claimableRewards: compRewards,
-                    },
-                },
-                account,
-            };
-            const userData = createBaseTypeUserState(payload, lenderData, totalDeposits24h, totalDebt24h);
-            return {
-                ...payload,
-                ...userData,
-            };
-        },
-        expectedNumberOfCalls,
-    ];
-};

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

@@ -1,28 +0,0 @@
-import { LenderUserQuery } from './types';
-import { GetEvmClientFunction } from '../../types';
-/**
- * Builds the multicall calls for the given queries and returns the raw results
- * @param chainId - The chain ID
- * @param queries - The queries to fetch data for
- * @param getEvmClient - Injected function to get EVM client
- * @param allowFailure - multicall can fail in single call, default is true - note that this might mess with the retries as it will never error
- * @param batchSize - multicall batch size, default is 4096
- * @param logs - show multicall error logs, default is false
- * @param lenderData - optional public lender data to dynamically use pols and assets provided externally
- * @returns The raw results from the multicall, "0x" for failures
- */
-export declare const getLenderUserDataResult: (chainId: string, queriesRaw: LenderUserQuery[], getEvmClient: GetEvmClientFunction, allowFailure?: boolean, batchSize?: number, retries?: number, logs?: boolean) => Promise<any[]>;
-/**
- * Converts the raw results into the desired format
- * @param chainId - The chain ID
- * @param queries - The queries to fetch data for
- * @param rawResults - The raw results from the multicall (getLenderUserDataResult)
- * @param prices - The prices for the assets
- * @param pricesHist - The historical prices for the assets
- * @param lenderState - The state of the lender
- * @returns The converted data
- */
-export declare const convertLenderUserDataResult: (chainId: string, queriesRaw: LenderUserQuery[], rawResults: any[], prices: any, pricesHist: any, lenderState: any) => {
-    [lender: string]: any;
-};
-//# sourceMappingURL=fetchUserData.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"fetchUserData.d.ts","sourceRoot":"","sources":["../../../src/lending/user-data/fetchUserData.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,eAAe,EAAuB,MAAM,SAAS,CAAA;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAgGlD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,MAAM,EACf,YAAY,eAAe,EAAE,EAC7B,cAAc,oBAAoB,EAClC,sBAAmB,EACnB,kBAAwC,EACxC,gBAAW,EACX,cAAY,KACX,OAAO,CAAC,GAAG,EAAE,CAgCf,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,GACtC,SAAS,MAAM,EACf,YAAY,eAAe,EAAE,EAC7B,YAAY,GAAG,EAAE,EACjB,QAAQ,GAAG,EACX,YAAY,GAAG,EACf,aAAa,GAAG,KACf;IAAE,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAA;CAoCzB,CAAA"}

package/dist/lending/user-data/fetchUserData.js

@@ -1,102 +0,0 @@
-import { MULTICALL_DEFAULT_BATCH_SIZE, multicallViemAbiArray, } from '../../utils/multicall';
-import { isAaveV2Type, isAaveV3Type, isInit, isMorphoType, isMultiMarket, isYLDR, } from '../../utils';
-import { organizeUserQueries } from './types';
-import { buildAaveV2UserCall } from './aave-v2-type/userCallBuild';
-import { buildAaveV3UserCall } from './aave-v3-type/userCallBuild';
-import { buildInitUserCall } from './init/userCallBuild';
-import { buildCompoundV3UserCall } from './compound-v3/userCallBuild';
-import { getAbi } from './abis';
-import { getAaveV2UserDataConverter } from './aave-v2-type/userCallParse';
-import { getAaveV3UserDataConverter } from './aave-v3-type/userCallParse';
-import { getInitUserDataConverter } from './init/userCallParse';
-import { getCompoundV3UserDataConverter } from './compound-v3/userCallParse';
-import { getYldrUserDataConverter } from './aave-v3-type/userCallParseYldr';
-import { buildMorphoUserCallWithLens } from './morpho/userCallBuild';
-import { getMorphoUserDataConverterWithlens } from './morpho/userCallParse';
-function buildUserCall(chainId, lender, account, params, assets) {
-    if (isAaveV2Type(lender))
-        return buildAaveV2UserCall(chainId, lender, account, assets);
-    if (isAaveV3Type(lender))
-        return buildAaveV3UserCall(chainId, lender, account, assets);
-    if (isInit(lender))
-        return buildInitUserCall(chainId, lender, account);
-    if (isMorphoType(lender))
-        return buildMorphoUserCallWithLens(chainId, account, lender, params);
-    return buildCompoundV3UserCall(chainId, lender, account, assets);
-}
-function getUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState, params) {
-    if (isYLDR(lender))
-        return getYldrUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState?.data?.[lender]?.data);
-    if (isAaveV2Type(lender))
-        return getAaveV2UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState?.data?.[lender]?.data);
-    if (isAaveV3Type(lender))
-        return getAaveV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState?.data?.[lender]?.data);
-    if (isInit(lender))
-        return getInitUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState?.data?.[lender]?.data);
-    if (isMorphoType(lender))
-        return getMorphoUserDataConverterWithlens(lender, chainId, account, params, prices, pricesHist, lenderPublicState?.data);
-    return getCompoundV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState?.data?.[lender]?.data);
-}
-/**
- * Builds the multicall calls for the given queries and returns the raw results
- * @param chainId - The chain ID
- * @param queries - The queries to fetch data for
- * @param getEvmClient - Injected function to get EVM client
- * @param allowFailure - multicall can fail in single call, default is true - note that this might mess with the retries as it will never error
- * @param batchSize - multicall batch size, default is 4096
- * @param logs - show multicall error logs, default is false
- * @param lenderData - optional public lender data to dynamically use pols and assets provided externally
- * @returns The raw results from the multicall, "0x" for failures
- */
-export const getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient, allowFailure = true, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, retries = 3, logs = false) => {
-    let calls = [];
-    const queries = organizeUserQueries(queriesRaw);
-    for (const query of queries) {
-        const abi = getAbi(query.lender);
-        const callData = buildUserCall(chainId, query.lender, query.account, query.params, query.assets);
-        const mappedCalls = callData.map((call) => ({ call, abi }));
-        calls = [...calls, ...mappedCalls];
-    }
-    return await multicallViemAbiArray(chainId, calls.map((call) => call.abi), calls.map((call) => call.call), getEvmClient, true, 0, retries, allowFailure, batchSize, logs);
-};
-/**
- * Converts the raw results into the desired format
- * @param chainId - The chain ID
- * @param queries - The queries to fetch data for
- * @param rawResults - The raw results from the multicall (getLenderUserDataResult)
- * @param prices - The prices for the assets
- * @param pricesHist - The historical prices for the assets
- * @param lenderState - The state of the lender
- * @returns The converted data
- */
-export const convertLenderUserDataResult = (chainId, queriesRaw, rawResults, prices, pricesHist, lenderState) => {
-    const queries = organizeUserQueries(queriesRaw);
-    const lenderData = {};
-    let currentSlice = 0;
-    for (const query of queries) {
-        const [converter, sliceLength] = getUserDataConverter(query.lender, chainId, query.account, prices, pricesHist, lenderState[chainId], query.params);
-        try {
-            const data = rawResults.slice(currentSlice, currentSlice + sliceLength);
-            const convertedData = converter(data);
-            if (convertedData) {
-                if (isMultiMarket(query.lender)) {
-                    Object.keys(convertedData).forEach((market) => {
-                        lenderData[market] = {
-                            // @ts-ignore
-                            [query.account.toLowerCase()]: convertedData[market],
-                        };
-                    });
-                }
-                else {
-                    // map it to the user address
-                    lenderData[query.lender] = {
-                        [query.account.toLowerCase()]: convertedData,
-                    };
-                }
-            }
-        }
-        catch (e) { }
-        currentSlice += sliceLength;
-    }
-    return lenderData;
-};

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

@@ -1,3 +0,0 @@
-export * from "./fetchUserData";
-export * from "./types";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lending/user-data/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA"}

package/dist/lending/user-data/index.js

@@ -1,2 +0,0 @@
-export * from "./fetchUserData";
-export * from "./types";

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

@@ -1,8 +0,0 @@
-import { Lender } from '@1delta/lender-registry';
-import { Call } from '../../../utils/multicall';
-export declare const initBrokerAddresses: {
-    "5000": string;
-};
-export declare function getInitFlashAggregatorAddress(chainId?: string): string | undefined;
-export declare const buildInitUserCall: (chainId: string, lender: Lender, account: string) => Call[];
-//# sourceMappingURL=userCallBuild.d.ts.map

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

@@ -1 +0,0 @@
-{"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,20 +0,0 @@
-import { Chain } from '@1delta/chain-registry';
-import { getInitLensAddress } from '../../addresses/init';
-export const initBrokerAddresses = {
-    [Chain.MANTLE]: '0xc08BFef7E778f3519D79E96780b77066F5d4FCC0',
-};
-export function getInitFlashAggregatorAddress(chainId) {
-    if (!chainId)
-        return undefined;
-    return initBrokerAddresses[chainId];
-}
-export const buildInitUserCall = (chainId, lender, account) => {
-    const lensContract = getInitLensAddress(chainId);
-    const brokerAddress = getInitFlashAggregatorAddress(chainId);
-    const call = {
-        address: lensContract,
-        name: 'getUserPositionData',
-        params: [account, brokerAddress],
-    };
-    return [call];
-};

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

@@ -1,8 +0,0 @@
-import { Lender } from '@1delta/lender-registry';
-import { InitUserReserveResponse } from "../types";
-export declare const getInitUserDataConverter: (lender: Lender, chainId: string, account: string, prices: {
-    [asset: string]: number;
-}, pricesHist: {
-    [asset: string]: number;
-}, lenderData: any) => [(data: any[]) => InitUserReserveResponse | undefined, number];
-//# sourceMappingURL=userCallParse.d.ts.map

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

@@ -1 +0,0 @@
-{"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,88 +0,0 @@
-import { getInitFlashAggregatorAddress } from "./userCallBuild";
-import { InitGetUserPositionDataIndexes } from "../../init/types";
-import { getLenderAssets } from "../../../utils";
-import { toOracleKey } from "../../../assets";
-import { parseRawAmount } from "../../../utils/parsing";
-import { createMultiAccountTypeUserState } from "../utils/createMultiAccountStyleUserState";
-export const getInitUserDataConverter = (lender, chainId, account, prices, pricesHist, lenderData) => {
-    const validOwner = account.toLowerCase();
-    const brokerAddress = getInitFlashAggregatorAddress(chainId) ?? '';
-    const expectedNumberOfCalls = 1;
-    return [
-        (_data) => {
-            if (_data.length !== expectedNumberOfCalls) {
-                return undefined;
-            }
-            const [data] = _data;
-            // filter for owner
-            const indexes = data[InitGetUserPositionDataIndexes.posMeta].map((e, i) => { return { e, i }; }).filter((a) => a.e.owner.toLowerCase() === validOwner).map((a) => a.i);
-            const assets = getLenderAssets(chainId, lender);
-            let histData = {};
-            // map data
-            const result = Object.assign({}, ...indexes.map((index) => {
-                const entry = data[InitGetUserPositionDataIndexes.posMeta][index];
-                const mode = entry.mode;
-                const id = entry.posId.toString();
-                const collatData = Object.assign({}, ...data[InitGetUserPositionDataIndexes.collaterals][index].map((c) => {
-                    const asset = c.underlying.toLowerCase();
-                    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 = lenderData[asset]?.asset?.decimals ?? 18;
-                    return { [asset]: { debt: parseRawAmount(c.amount.toString(), decimals) } };
-                }));
-                // sub account to asset data
-                return {
-                    [id]: {
-                        mode,
-                        ...Object.assign({}, ...assets.map(a => {
-                            const ams = toOracleKey(lenderData[a]?.asset?.assetGroup);
-                            const price = prices[ams] ?? 1;
-                            const priceHist = pricesHist?.[ams] ?? price;
-                            if (!histData[id])
-                                histData[id] = {
-                                    totalDebt24h: 0,
-                                    totalDeposits24h: 0,
-                                };
-                            const debt = debtData[a]?.debt ?? 0;
-                            const deposits = collatData[a]?.deposits ?? 0;
-                            const depositsRaw = collatData[a]?.depositsRaw ?? "0";
-                            histData[id].totalDebt24h += Number(debt) * priceHist;
-                            histData[id].totalDeposits24h += Number(deposits) * priceHist;
-                            // asset to data
-                            return {
-                                [a]: {
-                                    poolId: a,
-                                    underlying: a,
-                                    deposits: deposits,
-                                    depositsRaw,
-                                    debt: debt,
-                                    debtStable: "0",
-                                    debtStableUSD: 0,
-                                    depositsUSD: price * Number(deposits),
-                                    debtUSD: price * Number(debt),
-                                    collateralActive: true,
-                                    isAllowed: entry.approved.toLowerCase() === brokerAddress.toLowerCase(),
-                                }
-                            };
-                        }))
-                    }
-                };
-            }));
-            const payload = {
-                chainId,
-                lendingPositions: result,
-                account
-            };
-            const userState = createMultiAccountTypeUserState({ ...payload, assets }, lenderData, histData);
-            return {
-                ...payload,
-                ...userState
-            };
-        },
-        expectedNumberOfCalls,
-    ];
-};

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

@@ -1,21 +0,0 @@
-export interface BalanceInfo {
-    index: number;
-    supplyShares: bigint;
-    borrowShares: bigint;
-    supplyAssets: bigint;
-    borrowAssets: bigint;
-    collateral: bigint;
-}
-/**
- * Decode:
- *  [ uint256 count (32 bytes) ]
- *  then for each of `count` records:
- *    uint16  index (2 bytes),
- *    uint256 supplyShares (32 bytes),
- *    uint128 borrowShares (16 bytes),
- *    uint256 supplyAssets (32 bytes),
- *    uint256 borrowAssets (32 bytes),
- *    uint128 collateral   (16 bytes)
- */
-export declare function decodePackedDataset(hex: string): BalanceInfo[];
-//# sourceMappingURL=decoder.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/morpho/decoder.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAcD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,EAAE,CAsC9D"}

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

@@ -1,52 +0,0 @@
-const WORD = 32;
-const HALF = 16;
-/** Read `len` bytes at `off` as a big‐endian BigInt. */
-function readBigIntBE(buf, off, len) {
-    let v = 0n;
-    for (let i = 0; i < len; i++) {
-        v = (v << 8n) | BigInt(buf[off + i]);
-    }
-    return v;
-}
-/**
- * Decode:
- *  [ uint256 count (32 bytes) ]
- *  then for each of `count` records:
- *    uint16  index (2 bytes),
- *    uint256 supplyShares (32 bytes),
- *    uint128 borrowShares (16 bytes),
- *    uint256 supplyAssets (32 bytes),
- *    uint256 borrowAssets (32 bytes),
- *    uint128 collateral   (16 bytes)
- */
-export function decodePackedDataset(hex) {
-    if (hex.startsWith("0x"))
-        hex = hex.slice(2);
-    const buf = Uint8Array.from(hex.match(/.{1,2}/g).map((b) => parseInt(b, 16)));
-    // 1) count (uint256)
-    const count = Number(readBigIntBE(buf, 0, 2));
-    const out = [];
-    let off = 2;
-    for (let i = 0; i < count; i++) {
-        // 2) index (uint16)
-        const index = Number(readBigIntBE(buf, off, 2));
-        off += 2;
-        // 3) supplyShares (uint256)
-        const supplyShares = readBigIntBE(buf, off, WORD);
-        off += WORD;
-        // 4) borrowShares (uint128)
-        const borrowShares = readBigIntBE(buf, off, HALF);
-        off += HALF;
-        // 5) supplyAssets (uint256)
-        const supplyAssets = readBigIntBE(buf, off, WORD);
-        off += WORD;
-        // 6) borrowAssets (uint256)
-        const borrowAssets = readBigIntBE(buf, off, WORD);
-        off += WORD;
-        // 7) collateral (uint128)
-        const collateral = readBigIntBE(buf, off, HALF);
-        off += HALF;
-        out.push({ index, supplyShares, borrowShares, supplyAssets, borrowAssets, collateral });
-    }
-    return out;
-}

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

@@ -1,5 +0,0 @@
-export declare function toSharesDown(assets: bigint, totalAssets: bigint, totalShares: bigint): bigint;
-export declare function toAssetsDown(shares: bigint, totalAssets: bigint, totalShares: bigint): bigint;
-export declare function toSharesUp(assets: bigint, totalAssets: bigint, totalShares: bigint): bigint;
-export declare function toAssetsUp(shares: bigint, totalAssets: bigint, totalShares: bigint): bigint;
-//# sourceMappingURL=morphoLib.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"morphoLib.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/morpho/morphoLib.ts"],"names":[],"mappings":"AAcA,wBAAgB,YAAY,CACxB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GACpB,MAAM,CAMR;AAED,wBAAgB,YAAY,CACxB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GACpB,MAAM,CAMR;AAED,wBAAgB,UAAU,CACtB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GACpB,MAAM,CAMR;AAED,wBAAgB,UAAU,CACtB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GACpB,MAAM,CAMR"}