@1delta/margin-fetcher 0.0.1

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

@@ -0,0 +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;AAiB/C,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2BlC,CAAA"}

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

@@ -0,0 +1,46 @@
+import { isAaveV2Type, isAaveV3Type, isCompoundV3, isInit, isAaveV32Type } 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";
+export const getAbi = (lender) => {
+    if (isAaveV2Type(lender))
+        return [
+            ...AavePoolAndDataProviderAbi,
+            ...VariableDebtTokenAbi,
+            ...RewarderAbi,
+            ...PullRewardsIncentivesController,
+            ...IncentivesControllerAbi,
+            ...MultiFeeDistributionAbi
+        ];
+    if (isAaveV32Type(lender))
+        return [
+            ...AavePoolV3UpgradedAbi,
+            ...AaveV3ProtocolDataProviderAbi
+        ];
+    if (isAaveV3Type(lender))
+        return [
+            ...AavePoolLegacyAbi,
+            ...VariableDebtTokenAbi,
+            ...AavePoolDataProviderLegacyAbi
+        ];
+    if (isCompoundV3(lender))
+        return [
+            ...CometAbi,
+            ...CometExtAbi,
+            ...CometRewardsAbi,
+        ];
+    if (isInit(lender))
+        return InitLensAbi;
+    return [];
+};

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

@@ -0,0 +1,10 @@
+import { Lender } from "@1delta/asset-registry";
+export declare function getCompoundV3CometAddress(chainId: string, lender?: Lender): string | undefined;
+export declare function getCompoundV3CometRewardsAddress(chainId: string): string;
+export declare function getCompoundV3CometIRGetterAddress(chainId: string): string;
+export declare function getCompoundV3CometLens(chainId: string): string;
+export declare function getCompoundV3BaseAsset(lender: Lender | string, chainId: string): {
+    baseAsset: string;
+    baseBorrowMin: bigint;
+};
+//# sourceMappingURL=addresses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../../../src/lending/user-data/compound-v3/addresses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqD,MAAM,EAAwB,MAAM,wBAAwB,CAAA;AAExH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,SAA4B,GAAG,MAAM,GAAG,SAAS,CAE/G;AAED,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,MAAM,UAE/D;AAED,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,MAAM,UAEhE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,UAErD;AAmBD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,MAAM;;;EAE9E"}

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

@@ -0,0 +1,32 @@
+import { Chain, COMETS_PER_CHAIN_MAP, COMPOUND_BASE_TOKENS, Lender, SWAYLEND_BASE_TOKENS } from "@1delta/asset-registry";
+export function getCompoundV3CometAddress(chainId, lender = Lender.COMPOUND_V3_USDC_E) {
+    return COMETS_PER_CHAIN_MAP[chainId]?.[lender];
+}
+export function getCompoundV3CometRewardsAddress(chainId) {
+    return addressesCompoundV3.cometRewards[chainId];
+}
+export function getCompoundV3CometIRGetterAddress(chainId) {
+    return addressesCompoundV3.lens[chainId];
+}
+export function getCompoundV3CometLens(chainId) {
+    return addressesCompoundV3.lens[chainId];
+}
+const addressesCompoundV3 = {
+    lens: {
+        [Chain.POLYGON_MAINNET]: '0x4eDA401658c5286d16c4d342884F32280B4E8b1b',
+        [Chain.MANTLE]: '0x32B31A066c8dd3F7b77283Ba1d89Ddaf6DA0a8aE',
+        [Chain.ARBITRUM_ONE]: '0x13D9c35f4901491Ac4FFebd3100238BBfFBD7181',
+        [Chain.BASE]: "0x7e2D250E4FD0EeD6BD2cB3DC525A2b9f12508152",
+        [Chain.OP_MAINNET]: "0xA453ba397c61B0c292EA3959A858821145B2707F",
+    },
+    cometRewards: {
+        [Chain.POLYGON_MAINNET]: "0x45939657d1CA34A8FA39A924B71D28Fe8431e581",
+        [Chain.MANTLE]: "0xCd83CbBFCE149d141A5171C3D6a0F0fCCeE225Ab",
+        [Chain.ARBITRUM_ONE]: '0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae',
+        [Chain.BASE]: "0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1",
+        [Chain.OP_MAINNET]: "0x443EA0340cb75a160F31A440722dec7b5bc3C2E9",
+    }
+};
+export function getCompoundV3BaseAsset(lender, chainId) {
+    return COMPOUND_BASE_TOKENS[lender]?.[chainId] ?? SWAYLEND_BASE_TOKENS[lender]?.[chainId];
+}

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

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

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

@@ -0,0 +1 @@
+{"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;AAC/B,cAAc,aAAa,CAAA"}

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

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

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

@@ -0,0 +1,4 @@
+import { Lender } from "@1delta/asset-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

@@ -0,0 +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;AAI/C,eAAO,MAAM,uBAAuB,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,EAAE,SAAS,MAAM,KAAG,IAAI,EA+C9F,CAAA"}

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

@@ -0,0 +1,44 @@
+import { getComposerAddress, getLenderAssets } from "../../../utils";
+import { getCompoundV3BaseAsset, getCompoundV3CometAddress, getCompoundV3CometRewardsAddress } from "./addresses";
+export const buildCompoundV3UserCall = (chainId, lender, account) => {
+    const baseAsset = getCompoundV3BaseAsset(lender, chainId).baseAsset;
+    const cometContractAddress = getCompoundV3CometAddress(chainId, lender);
+    const assets = getLenderAssets(chainId, lender);
+    const assetsNoBase = assets.filter(a => a !== baseAsset);
+    const allowedCall = {
+        address: cometContractAddress,
+        name: 'isAllowed',
+        params: [account, getComposerAddress(chainId)],
+    };
+    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,
+        allowedCall,
+        callEarnedBalances
+    ];
+    return calls;
+};

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

@@ -0,0 +1,8 @@
+import { Lender } from "@1delta/asset-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

@@ -0,0 +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;AAE/C,OAAO,EAAE,6BAA6B,EAAwC,MAAM,UAAU,CAAA;AAO9F,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,CA0GrE,CAAA"}

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

@@ -0,0 +1,98 @@
+import { getAssetMeta, getCompoundV3Assets, toOracleKey } from "../../../assets";
+import { getCompoundV3BaseAsset } from "./addresses";
+import { parseRawAmount } from "../../../utils/parsing";
+import { Asset as SupportedAssets } from "@1delta/asset-registry";
+import { createBaseTypeUserState } from "../utils";
+export const getCompoundV3UserDataConverter = (lender, chainId, account, prices, pricesHist, lenderData) => {
+    const assetAddresses = getCompoundV3Assets(chainId, lender);
+    const baseAsset = getCompoundV3BaseAsset(lender, chainId).baseAsset;
+    const assetsNoBase = assetAddresses.filter(a => a !== baseAsset);
+    const expectedNumberOfCalls = assetsNoBase.length + 2 + 1 + 1;
+    return [
+        (data) => {
+            if (data.length !== expectedNumberOfCalls) {
+                return undefined;
+            }
+            const isAllowed = Boolean(data[expectedNumberOfCalls - 2]);
+            let totalDebt24h = 0;
+            let totalDeposits24h = 0;
+            let result = {};
+            for (let i = 0; i < assetsNoBase.length; i++) {
+                const asset = assetsNoBase[i];
+                const assetMeta = getAssetMeta(chainId, asset);
+                const decimals = assetMeta?.decimals ?? 18;
+                const depositsRaw = data[i][0]?.toString();
+                const deposits = parseRawAmount(depositsRaw, decimals);
+                const price = prices[toOracleKey(assetMeta.assetGroup)] ?? 1;
+                const priceHist = pricesHist?.[toOracleKey(assetMeta.assetGroup)] ?? price;
+                // accure
+                totalDeposits24h += Number(deposits) * priceHist;
+                result[asset] = {
+                    poolId: asset,
+                    underlying: asset,
+                    deposits,
+                    depositsUSD: Number(deposits) * price,
+                    debtStableUSD: 0,
+                    debt: 0,
+                    debtUSD: 0,
+                    collateralActive: true,
+                    // user depos raw
+                    depositsRaw,
+                    // flag for allowance
+                    isAllowed,
+                };
+            }
+            const depositsRaw = data[assetsNoBase.length]?.toString();
+            const debtRaw = data[assetsNoBase.length + 1]?.toString();
+            const baseMeta = getAssetMeta(chainId, baseAsset);
+            const baseDecimals = baseMeta.decimals ?? 18;
+            const deposits = parseRawAmount(depositsRaw, baseDecimals);
+            const debt = parseRawAmount(debtRaw, baseDecimals);
+            const priceBase = prices[toOracleKey(baseMeta.assetGroup)];
+            const priceBaseHist = pricesHist?.[toOracleKey(baseMeta.assetGroup)] ?? 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
+                    isAllowed,
+                },
+            };
+            // 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: {
+                    [SupportedAssets.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

@@ -0,0 +1,24 @@
+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
+ * @returns The raw results from the multicall
+ */
+export declare const getLenderUserDataResult: (chainId: string, queries: LenderUserQuery[], getEvmClient: GetEvmClientFunction) => 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, queries: 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

@@ -0,0 +1 @@
+{"version":3,"file":"fetchUserData.d.ts","sourceRoot":"","sources":["../../../src/lending/user-data/fetchUserData.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAoClD;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,MAAM,EACf,SAAS,eAAe,EAAE,EAC1B,cAAc,oBAAoB,KACjC,OAAO,CAAC,GAAG,EAAE,CAsBf,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,GACtC,SAAS,MAAM,EACf,SAAS,eAAe,EAAE,EAC1B,YAAY,GAAG,EAAE,EACjB,QAAQ,GAAG,EACX,YAAY,GAAG,EACf,aAAa,GAAG,KACf;IAAE,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAA;CA4BzB,CAAA"}

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

@@ -0,0 +1,76 @@
+import { multicallViemAbiArray } from "../../utils/multicall";
+import { Lender } from "@1delta/asset-registry";
+import { isAaveV2Type, isAaveV3Type, isInit } from "../../utils";
+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";
+function buildUserCall(chainId, lender, account) {
+    if (isAaveV2Type(lender))
+        return buildAaveV2UserCall(chainId, lender, account);
+    if (isAaveV3Type(lender))
+        return buildAaveV3UserCall(chainId, lender, account);
+    if (isInit(lender))
+        return buildInitUserCall(chainId, lender, account);
+    return buildCompoundV3UserCall(chainId, lender, account);
+}
+function getUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState) {
+    if (isAaveV2Type(lender))
+        return getAaveV2UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState);
+    if (isAaveV3Type(lender))
+        return getAaveV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState);
+    if (lender === Lender.INIT)
+        return getInitUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState);
+    return getCompoundV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState);
+}
+/**
+ * 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
+ * @returns The raw results from the multicall
+ */
+export const getLenderUserDataResult = async (chainId, queries, getEvmClient) => {
+    let calls = [];
+    for (const query of queries) {
+        const abi = getAbi(query.lender);
+        const callData = buildUserCall(chainId, query.lender, query.account);
+        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, 3);
+};
+/**
+ * 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, queries, rawResults, prices, pricesHist, lenderState) => {
+    const lenderData = {};
+    let currentSlice = 0;
+    for (const query of queries) {
+        const [converter, sliceLength] = getUserDataConverter(query.lender, chainId, query.account, prices, pricesHist, lenderState[query.lender]?.[chainId]?.lenderData);
+        try {
+            const data = rawResults.slice(currentSlice, currentSlice + sliceLength);
+            const convertedData = converter(data);
+            if (convertedData) {
+                lenderData[query.lender] = convertedData;
+            }
+        }
+        catch (e) {
+            console.log("Error parsing for", query.lender, "on", chainId, e);
+        }
+        currentSlice += sliceLength;
+    }
+    return lenderData;
+};

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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1,8 @@
+import { Lender } from "@1delta/asset-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

@@ -0,0 +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"}

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

@@ -0,0 +1,20 @@
+import { Chain } from "@1delta/asset-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

@@ -0,0 +1,8 @@
+import { Lender } from "@1delta/asset-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

@@ -0,0 +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;AAE/C,OAAO,EAAE,uBAAuB,EAAwC,MAAM,UAAU,CAAA;AAQxF,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,CAiG/D,CAAA"}

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

@@ -0,0 +1,87 @@
+import { Lender } from "@1delta/asset-registry";
+import { getInitFlashAggregatorAddress } from "./userCallBuild";
+import { InitGetUserPositionDataIndexes } from "../../init/types";
+import { getLenderAssets } from "../../../utils";
+import { getAssetMeta, 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.INIT);
+            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 = getAssetMeta(chainId, 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;
+                    return { [asset]: { debt: parseRawAmount(c.amount.toString(), decimals) } };
+                }));
+                return {
+                    [id]: {
+                        mode,
+                        ...Object.assign({}, ...assets.map(a => {
+                            const ams = toOracleKey(getAssetMeta(chainId, a)?.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;
+                            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,
+    ];
+};