@kasufinance/kasu-sdk 1.0.1

package/dist/services/DataService/data-service.js

@@ -0,0 +1,586 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { authentication, createDirectus, readItems, readSingleton, rest, } from '@directus/sdk';
+import { formatUnits } from 'ethers/lib/utils';
+import { GraphQLClient } from 'graphql-request';
+import { KasuPoolExternalTVLAbi__factory, } from '../../contracts';
+import { getSystemVariablesQuery } from '../Locking/queries';
+import { filterArray } from '../shared';
+import { getAllTrancheConfigurationsQuery, getAllTranchesQuery, getLendingPoolWithdrawalAndDepositsQuery, getPlumeTvl, getPoolNameQuery, getPoolOverviewQuery, } from './queries';
+export class DataService {
+    constructor(_kasuConfig, signerOrProvider) {
+        this._kasuConfig = _kasuConfig;
+        this._plumeTvl = new Map();
+        this._externalTvlAbi = KasuPoolExternalTVLAbi__factory.connect(_kasuConfig.contracts.ExternalTVL, signerOrProvider);
+        this._graph = new GraphQLClient(_kasuConfig.subgraphUrl);
+        this._plumeGraph = new GraphQLClient(_kasuConfig.plumeSubgraphUrl);
+        this._directus = createDirectus(_kasuConfig.directusUrl)
+            .with(authentication())
+            .with(rest());
+    }
+    getUrlFromFile(fileName) {
+        return `${this._kasuConfig.directusUrl}assets/${fileName}`;
+    }
+    calculatePoolCapacity(poolCapacities, poolCapacityPercentages, index, spillOver, lendingPoolSubgraph, lendingPoolConfig) {
+        const desiredDrawAmount = lendingPoolConfig.desiredDrawAmount; // subgraph
+        const desiredTrancheRatio = lendingPoolConfig.tranchesConfig[index].desiredRatio;
+        const targetDrawAmount = parseFloat(desiredDrawAmount) *
+            (parseFloat(desiredTrancheRatio) / 100);
+        const pendingDeposits = parseFloat(lendingPoolSubgraph.pendingPool.totalPendingDepositAmounts[index]) - spillOver;
+        const balance = parseFloat(lendingPoolSubgraph.tranches[index].balance); // subgraph
+        const targetAmount = balance + targetDrawAmount;
+        const remainingCapacity = Math.max(targetDrawAmount - pendingDeposits, 0);
+        const remainingCapacityPercentage = targetAmount != 0 ? remainingCapacity / targetAmount : 0;
+        const remainingCapacitySpillover = Math.min(targetDrawAmount - pendingDeposits, 0);
+        poolCapacities.push(remainingCapacity);
+        poolCapacityPercentages.push(remainingCapacityPercentage);
+        if (index === lendingPoolConfig.tranchesConfig.length - 1) {
+            return {
+                poolCapacity: poolCapacities,
+                poolCapacityPercentage: poolCapacityPercentages,
+            };
+        }
+        return this.calculatePoolCapacity(poolCapacities, poolCapacityPercentages, index + 1, remainingCapacitySpillover, lendingPoolSubgraph, lendingPoolConfig);
+    }
+    calculateApyForTranche(interestRate) {
+        const EPOCHS_IN_YEAR = 52.17857;
+        return Math.pow((1 + parseFloat(interestRate)), EPOCHS_IN_YEAR) - 1;
+    }
+    getPlatformOverview() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._directus.request(readSingleton('PlatformOverview'));
+        });
+    }
+    getNftBoost() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._directus.request(readSingleton('NftBoost'));
+        });
+    }
+    getOffChainTvl(poolIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tvlMap = new Map();
+            try {
+                const results = yield Promise.all(poolIds.map((id) => __awaiter(this, void 0, void 0, function* () {
+                    return [
+                        id,
+                        yield this._externalTvlAbi.externalTVLOfPool(id),
+                    ];
+                })));
+                for (const [id, tvl] of results) {
+                    tvlMap.set(id, formatUnits(tvl, 6));
+                }
+            }
+            catch (error) {
+                console.error('getOffChainTvl :', error);
+            }
+            return tvlMap;
+        });
+    }
+    getPoolOverview(epochId, id_in) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const trancheNames = [
+                ['Senior'],
+                ['Junior', 'Senior'],
+                ['Junior', 'Mezzanine', 'Senior'],
+            ];
+            const poolOverviewResults = yield this._graph.request(getPoolOverviewQuery(id_in), {
+                unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
+                epochId,
+            });
+            if (!this._plumeTvl.size) {
+                const plumeResults = yield this._plumeGraph.request(getPlumeTvl);
+                for (const pool of plumeResults.lendingPools) {
+                    this._plumeTvl.set(pool.id, pool.balance);
+                }
+            }
+            if (!this._directusPoolOverview) {
+                this._directusPoolOverview = yield this._directus.request(readItems('PoolOverview', {
+                    filter: {
+                        enabled: {
+                            _eq: true,
+                        },
+                    },
+                }));
+            }
+            const offchainTvlMap = yield this.getOffChainTvl(poolOverviewResults.lendingPools.map(({ id }) => id));
+            const retn = [];
+            for (const lendingPoolSubgraph of poolOverviewResults.lendingPools) {
+                const lendingPoolDirectus = this._directusPoolOverview.find((r) => r.id.toLowerCase() == lendingPoolSubgraph.id);
+                const lendingPoolConfig = lendingPoolSubgraph.configuration;
+                if (!lendingPoolDirectus) {
+                    console.warn("Couldn't find directus pool for id: ", lendingPoolSubgraph.id);
+                    continue;
+                }
+                const poolCapacities = this.calculatePoolCapacity([], [], 0, 0, lendingPoolSubgraph, lendingPoolConfig);
+                const tranches = lendingPoolSubgraph.tranches
+                    .map((tranche) => {
+                    const trancheConfig = lendingPoolSubgraph.configuration.tranchesConfig.find((r) => r.id == tranche.id);
+                    if (!trancheConfig) {
+                        console.warn("Couldn't find tranche config for id: ", tranche.id);
+                        return null;
+                    }
+                    const interestUpdates = trancheConfig.lendingPoolTrancheInterestRateUpdates;
+                    const interestRate = interestUpdates.length
+                        ? interestUpdates[0].epochInterestRate
+                        : trancheConfig.interestRate;
+                    const baseApy = this.calculateApyForTranche(interestRate);
+                    let minApy = baseApy;
+                    let maxApy = baseApy;
+                    const fixedTermConfig = trancheConfig.lendingPoolTrancheFixedTermConfigs.map((fixedTermConfig) => {
+                        const fixedTermApy = this.calculateApyForTranche(fixedTermConfig.epochInterestRate);
+                        minApy = Math.min(minApy, fixedTermApy);
+                        maxApy = Math.max(maxApy, fixedTermApy);
+                        return {
+                            configId: fixedTermConfig.configId,
+                            apy: fixedTermApy.toString(),
+                            epochLockDuration: fixedTermConfig.epochLockDuration,
+                            epochInterestRate: fixedTermConfig.epochInterestRate,
+                            fixedTermDepositStatus: fixedTermConfig.fixedTermDepositStatus,
+                            fixedTermDepositAllowlist: fixedTermConfig.fixedTermDepositAllowlist.map((allowList) => ({
+                                isAllowlisted: allowList.isAllowlisted,
+                                userId: allowList.user.id,
+                            })),
+                        };
+                    });
+                    const averageApy = fixedTermConfig.length
+                        ? fixedTermConfig.reduce((total, cur) => (total += parseFloat(cur.apy)), 0) / fixedTermConfig.length
+                        : baseApy;
+                    return {
+                        id: tranche.id,
+                        apy: baseApy.toString(),
+                        minApy: minApy.toString(),
+                        maxApy: maxApy.toString(),
+                        averageApy: averageApy.toString(),
+                        interestRate,
+                        maximumDeposit: trancheConfig.maxDepositAmount,
+                        minimumDeposit: trancheConfig.minDepositAmount,
+                        poolCapacityPercentage: poolCapacities.poolCapacityPercentage[parseInt(tranche.orderId)].toString(),
+                        poolCapacity: poolCapacities.poolCapacity[parseInt(tranche.orderId)].toString(),
+                        name: trancheNames[lendingPoolSubgraph.tranches.length - 1][parseInt(tranche.orderId)],
+                        fixedTermConfig,
+                    };
+                })
+                    .filter((tranche) => tranche !== null);
+                const poolCapacitySum = poolCapacities.poolCapacity.reduce((a, b) => a + b, 0);
+                const poolCapacityPercentageSum = poolCapacities.poolCapacityPercentage.reduce((a, b) => a + b, 0) / poolCapacities.poolCapacity.length;
+                const trancheBalanceSum = lendingPoolSubgraph.tranches.reduce((a, b) => a + parseFloat(b.balance), 0);
+                let averageApy = 0;
+                for (const tranche of lendingPoolSubgraph.tranches) {
+                    const trancheData = tranches.find((r) => r.id.toLowerCase() == tranche.id);
+                    if (!trancheData) {
+                        console.warn("Couldn't find tranche directus for id: ", tranche.id);
+                        continue;
+                    }
+                    const weight = trancheBalanceSum == 0
+                        ? 0
+                        : parseFloat(tranche.balance) / trancheBalanceSum;
+                    averageApy += parseFloat(trancheData.averageApy) * weight;
+                }
+                const plumeTvl = lendingPoolDirectus.plumeStrategy &&
+                    this._plumeTvl.has(lendingPoolDirectus.plumeStrategy)
+                    ? (_a = this._plumeTvl.get(lendingPoolDirectus.plumeStrategy)) !== null && _a !== void 0 ? _a : '0'
+                    : '0';
+                const offChainTvl = (_b = offchainTvlMap.get(lendingPoolSubgraph.id)) !== null && _b !== void 0 ? _b : '0';
+                const poolOverview = {
+                    id: lendingPoolSubgraph.id,
+                    security: lendingPoolDirectus.security,
+                    enabled: lendingPoolDirectus.enabled,
+                    isOversubscribed: lendingPoolDirectus.oversubscribed,
+                    apy: averageApy,
+                    description: lendingPoolDirectus.description,
+                    liteDescription: lendingPoolDirectus.liteDescription,
+                    thumbnailImageUrl: this.getUrlFromFile(lendingPoolDirectus.thumbnailImage),
+                    bannerImageUrl: this.getUrlFromFile(lendingPoolDirectus.bannerImage),
+                    strategyDeckUrl: this.getUrlFromFile(lendingPoolDirectus.strategyDeck),
+                    assetClass: lendingPoolDirectus.assetClass,
+                    industryExposure: lendingPoolDirectus.industryExposure,
+                    poolApyStructure: lendingPoolDirectus.poolApyStructure,
+                    apyExpiryDate: lendingPoolDirectus.apyExpiryDate,
+                    poolInvestmentTerm: lendingPoolDirectus.poolInvestmentTerm,
+                    loanStructure: lendingPoolDirectus.loanStructure,
+                    poolName: (_c = lendingPoolDirectus.poolName) !== null && _c !== void 0 ? _c : lendingPoolSubgraph.name,
+                    subheading: lendingPoolDirectus.subheading,
+                    totalValueLocked: {
+                        total: (parseFloat(lendingPoolSubgraph.balance) +
+                            parseFloat(plumeTvl) +
+                            parseFloat(offChainTvl)).toString(),
+                        offchain: offChainTvl,
+                        plume: plumeTvl,
+                    },
+                    loansUnderManagement: lendingPoolDirectus.loansUnderManagement,
+                    yieldEarned: lendingPoolSubgraph.totalUserInterestAmount,
+                    poolCapacity: poolCapacitySum.toString(),
+                    poolCapacityPercentage: poolCapacityPercentageSum.toString(),
+                    activeLoans: lendingPoolDirectus.activeLoans,
+                    loanFundsOriginated: lendingPoolDirectus.loanFundsOriginated,
+                    tranches: tranches,
+                    isActive: !lendingPoolSubgraph.isStopped,
+                    requestEpochsInAdvance: lendingPoolSubgraph.configuration
+                        .lendingPoolWithdrawalConfig.requestEpochsInAdvance,
+                };
+                // show only enabled pools from cms
+                if (poolOverview.enabled) {
+                    retn.push(poolOverview);
+                }
+            }
+            return retn;
+        });
+    }
+    getPerformanceFee() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const systemVariables = yield this._graph.request(getSystemVariablesQuery);
+            return parseFloat(systemVariables.systemVariables.performanceFee);
+        });
+    }
+    getRiskManagement(id_in) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [resultDirectusRiskManagement, resultDirectusRiskManagementItem, resultDirectusRiskManagementGroups,] = yield Promise.all([
+                this._directus.request(readItems('RiskManagement')),
+                this._directus.request(readItems('RiskManagementItems')),
+                this._directus.request(readItems('RiskManagementGroups')),
+            ]);
+            const groupMapper = resultDirectusRiskManagementGroups.reduce((acc, cur) => (Object.assign(Object.assign({}, acc), { [cur.name]: cur })), {});
+            const itemMapper = resultDirectusRiskManagementItem.reduce((acc, cur) => {
+                var _a;
+                const groupName = (_a = groupMapper[cur.group.key]) === null || _a === void 0 ? void 0 : _a.name;
+                if (!groupName)
+                    return acc;
+                return Object.assign(Object.assign({}, acc), { [cur.name]: Object.assign(Object.assign({}, cur), { group: groupName }) });
+            }, {});
+            const riskManagement = resultDirectusRiskManagement.map((risk) => {
+                const items = risk.riskManagementItems
+                    .map((data) => {
+                    const { riskManagementItem } = data, rest = __rest(data, ["riskManagementItem"]);
+                    const item = itemMapper[riskManagementItem.key];
+                    if (!item)
+                        return null;
+                    return Object.assign(Object.assign({}, rest), item);
+                })
+                    .filter((item) => item !== null);
+                return {
+                    id: risk.id,
+                    poolIdFK: risk.poolIdFK.toLowerCase(),
+                    items,
+                    riskPerformance: {
+                        id: risk.id,
+                        firstLossCapital: risk.firstLossCapital,
+                        poolLossRate: risk.poolLossRate,
+                        independentRiskScore: risk.independentRiskScore,
+                        communityRating: risk.communityRating,
+                    },
+                };
+            });
+            return filterArray(riskManagement, id_in);
+        });
+    }
+    getPoolDelegateProfileAndHistory(id_in) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const poolDelegateProfileAndHistoryDirectus = (yield this._directus.request(readItems('PoolDelegateProfileAndHistory', {
+                // @ts-expect-error this is correct and works
+                fields: ['*', { otherPools: ['*'] }],
+            })));
+            const [poolNames, directusPoolNames] = yield Promise.all([
+                this._graph.request(getPoolNameQuery, {
+                    ids: poolDelegateProfileAndHistoryDirectus.flatMap((directus) => directus.otherPools.map((delegate) => delegate.PoolOverview_id)),
+                    unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
+                }),
+                this._directus.request(readItems('PoolOverview', {
+                    fields: ['id', 'poolName', 'subheading', 'oversubscribed'],
+                })),
+            ]);
+            const retn = [];
+            for (const data of poolDelegateProfileAndHistoryDirectus) {
+                const otherKASUPools = [];
+                for (const otherPool of data.otherPools) {
+                    const found = poolNames.lendingPools.find(({ id }) => otherPool.PoolOverview_id === id);
+                    if (!found)
+                        continue;
+                    const directusName = directusPoolNames.find(({ id }) => id === found.id);
+                    const poolName = (_a = directusName === null || directusName === void 0 ? void 0 : directusName.poolName) !== null && _a !== void 0 ? _a : found.name;
+                    otherKASUPools.push({
+                        id: found.id,
+                        name: (directusName === null || directusName === void 0 ? void 0 : directusName.subheading)
+                            ? `${poolName} - ${directusName.subheading}`
+                            : poolName,
+                        isActive: !found.isStopped,
+                        isOversubscribed: Boolean(directusName === null || directusName === void 0 ? void 0 : directusName.oversubscribed),
+                    });
+                }
+                retn.push({
+                    id: data.id,
+                    delegateLendingHistory: data.delegateLendingHistory,
+                    assetClasses: data.assetClasses,
+                    otherKASUPools,
+                    totalLoanFundsOriginated: data.totalLoanFundsOriginated,
+                    totalLoansOriginated: data.totalLoansOriginated,
+                    loansUnderManagement: data.loansUnderManagement,
+                    historicLossRate: data.historicLossRate,
+                });
+            }
+            return filterArray(retn, id_in);
+        });
+    }
+    getPoolTranches(epochId, id_in) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subgraphResults = yield this._graph.request(getAllTranchesQuery, {
+                unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
+            });
+            const subgraphConfigurationResults = yield this._graph.request(getAllTrancheConfigurationsQuery, {
+                unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
+                epochId,
+            });
+            const retn = [];
+            for (const trancheSubgraph of subgraphResults.lendingPoolTranches) {
+                const configuration = subgraphConfigurationResults.lendingPoolTrancheConfigurations.find((r) => r.id == trancheSubgraph.id);
+                if (!configuration) {
+                    console.warn("Couldn't find tranche configuration for id: ", trancheSubgraph.id);
+                    continue;
+                }
+                const interestUpdates = configuration.lendingPoolTrancheInterestRateUpdates;
+                const interestRate = interestUpdates.length
+                    ? interestUpdates[0].epochInterestRate
+                    : configuration.interestRate;
+                const tranche = {
+                    id: trancheSubgraph.id,
+                    poolIdFK: trancheSubgraph.lendingPool.id.toLowerCase(),
+                    apy: this.calculateApyForTranche(interestRate).toString(),
+                    minimalDepositThreshold: configuration.minDepositAmount,
+                    maximalDepositThreshold: configuration.maxDepositAmount,
+                };
+                retn.push(tranche);
+            }
+            return filterArray(retn, id_in);
+        });
+    }
+    getBadAndDoubtfulDebts(id_in) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [badAndDoubtfulDebtsItemsDirectus, badAndDoubtfulDebtsDirectus] = yield Promise.all([
+                this._directus.request(readItems('BadAndDoubtfulDebtsItems')),
+                this._directus.request(readItems('BadAndDoubtfulDebts')),
+            ]);
+            const itemsMapper = badAndDoubtfulDebtsItemsDirectus.reduce((acc, cur) => (Object.assign(Object.assign({}, acc), { [cur.id]: cur })), {});
+            const test = badAndDoubtfulDebtsDirectus.map((debts) => {
+                const items = debts.items
+                    .map((debtItem) => {
+                    const { item } = debtItem, metric = __rest(debtItem, ["item"]);
+                    const itemMetric = itemsMapper[item.key];
+                    if (!itemMetric)
+                        return null;
+                    return Object.assign(Object.assign({}, metric), { item: itemMetric });
+                })
+                    .filter((item) => item !== null);
+                return Object.assign(Object.assign({}, debts), { items });
+            });
+            return filterArray(test, id_in);
+        });
+    }
+    getPoolCreditMetrics(id_in) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [keyCreditMetricsDirectus, poolCreditMetricsDirectus] = yield Promise.all([
+                this._directus.request(readItems('KeyCreditMetrics')),
+                this._directus.request(readItems('PoolCreditMetrics')),
+            ]);
+            const keyCreditMetricsMapper = keyCreditMetricsDirectus.reduce((acc, cur) => (Object.assign(Object.assign({}, acc), { [cur.name]: cur })), {});
+            const poolCreditMetrics = poolCreditMetricsDirectus.map((pool) => {
+                const metrics = pool.keyCreditMetrics
+                    .map((data) => {
+                    const { keyCreditMetric } = data, metric = __rest(data, ["keyCreditMetric"]);
+                    const keyMetric = keyCreditMetricsMapper[keyCreditMetric.key];
+                    if (!keyMetric)
+                        return null;
+                    return Object.assign(Object.assign({}, metric), { keyCreditMetric: keyMetric });
+                })
+                    .filter((metric) => metric !== null);
+                return Object.assign(Object.assign({}, pool), { keyCreditMetrics: metrics });
+            });
+            return filterArray(poolCreditMetrics, id_in);
+        });
+    }
+    getFinancialReportingDocuments(id_in) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [financialReportingDocumentsDirectus, financialReportingDocumentsItemsDirectus,] = yield Promise.all([
+                this._directus.request(readItems('FinancialReportingDocuments')),
+                this._directus.request(readItems('FinancialReportingDocumentsItems')),
+            ]);
+            const documentItemsMapper = financialReportingDocumentsItemsDirectus.reduce((acc, cur) => (Object.assign(Object.assign({}, acc), { [cur.id]: cur })), {});
+            const mapDocumentFilePath = financialReportingDocumentsDirectus
+                .map((report) => {
+                if (!report.documents)
+                    return null;
+                const documents = report.documents
+                    .map((documentId) => {
+                    const document = documentItemsMapper[documentId];
+                    if (!document)
+                        return null;
+                    return Object.assign(Object.assign({}, document), { document: this.getUrlFromFile(document.document) });
+                })
+                    .filter((document) => document !== null);
+                return Object.assign(Object.assign({}, report), { documents });
+            })
+                .filter((report) => report !== null);
+            return filterArray(mapDocumentFilePath, id_in);
+        });
+    }
+    getRepayments(id_in) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [poolRepaymentDirectus, poolRepaymentItemsDirectus] = yield Promise.all([
+                this._directus.request(readItems('PoolRepayments', {
+                    filter: {
+                        poolIdFK: {
+                            _nin: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
+                        },
+                    },
+                })),
+                this._directus.request(readItems('PoolRepaymentItems')),
+            ]);
+            const repaymentItemsMapper = poolRepaymentItemsDirectus.reduce((acc, cur) => (Object.assign(Object.assign({}, acc), { [cur.name]: cur })), {});
+            const lendingPoolsWithdrawalsAndDepositsSubgraph = yield this._graph.request(getLendingPoolWithdrawalAndDepositsQuery, { unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS });
+            const retn = [];
+            for (const data of poolRepaymentDirectus) {
+                const lendingPoolSubgraph = lendingPoolsWithdrawalsAndDepositsSubgraph.lendingPools.find((pool) => pool.id == data.poolIdFK);
+                if (lendingPoolSubgraph === undefined) {
+                    continue;
+                }
+                const currentDepositRequests = parseFloat(lendingPoolSubgraph.pendingPool.totalPendingDepositsAmount);
+                let sumTotalPendingWithdrawalShares = 0.0;
+                lendingPoolSubgraph.pendingPool.totalPendingWithdrawalShares.forEach((shares) => {
+                    sumTotalPendingWithdrawalShares += parseFloat(shares);
+                });
+                const cumulativeLendingAndWithdrawals = data.CumulativeLendingAndWithdrawals.map((fund) => {
+                    var _a;
+                    let calculatedValue = 0;
+                    if (fund.key === 'netLendingWithdrawals') {
+                        calculatedValue =
+                            parseFloat(lendingPoolSubgraph.totalDepositsAccepted) -
+                                parseFloat(lendingPoolSubgraph.totalWithdrawalsAccepted);
+                    }
+                    if (fund.key === 'cumulativeLending') {
+                        calculatedValue = parseFloat(lendingPoolSubgraph.totalDepositsAccepted);
+                    }
+                    if (fund.key === 'cumulativeLendingWithdrawals') {
+                        calculatedValue = parseFloat(lendingPoolSubgraph.totalWithdrawalsAccepted);
+                    }
+                    const repaymentItem = repaymentItemsMapper[fund.repaymentItem.key];
+                    if (!repaymentItem)
+                        return null;
+                    return Object.assign({ value: (_a = fund.value) !== null && _a !== void 0 ? _a : calculatedValue }, repaymentItem);
+                }).filter((item) => item !== null);
+                const lendingAndWithdrawalRequests = data.LendingAndWithdrawalRequests.map((fund) => {
+                    var _a;
+                    let calculatedValue = 0;
+                    if (fund.key === 'netLendingWithdrawalRequests') {
+                        calculatedValue =
+                            currentDepositRequests -
+                                sumTotalPendingWithdrawalShares;
+                    }
+                    if (fund.key === 'currentLendingRequests') {
+                        calculatedValue = currentDepositRequests;
+                    }
+                    if (fund.key === 'currentLendingWithdrawalRequests') {
+                        calculatedValue = sumTotalPendingWithdrawalShares;
+                    }
+                    const repaymentItem = repaymentItemsMapper[fund.repaymentItem.key];
+                    if (!repaymentItem)
+                        return null;
+                    return Object.assign({ value: (_a = fund.value) !== null && _a !== void 0 ? _a : calculatedValue }, repaymentItem);
+                }).filter((item) => item !== null);
+                const poolRepayment = {
+                    id: data.id,
+                    poolIdFK: data.poolIdFK.toLowerCase(),
+                    currentTotalEndBorrowers: data.currentTotalEndBorrowers,
+                    repaymentsFileUrl: this.getUrlFromFile(data.repaymentsFile),
+                    upcomingLendingFundsFlow: data.UpcomingLendingFundsFlow.map((fund) => {
+                        const repaymentItem = repaymentItemsMapper[fund.repaymentItem.key];
+                        if (!repaymentItem)
+                            return null;
+                        return Object.assign({ value: fund.value }, repaymentItem);
+                    }).filter((item) => item !== null),
+                    cumulativeLendingFundsFlow: data.CumulativeLendingFundsFlow.map((fund) => {
+                        const repaymentItem = repaymentItemsMapper[fund.repaymentItem.key];
+                        if (!repaymentItem)
+                            return null;
+                        return Object.assign({ value: fund.value }, repaymentItem);
+                    }).filter((item) => item !== null),
+                    cumulativeLendingAndWithdrawals,
+                    lendingAndWithdrawalRequests,
+                };
+                retn.push(poolRepayment);
+            }
+            return filterArray(retn, id_in);
+        });
+    }
+    getLendingTotals(poolOverviews) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const riskManagements = yield this.getRiskManagement();
+            const retn = {
+                totalValueLocked: 0,
+                loansUnderManagement: 0,
+                totalLoanFundsOriginated: 0,
+                totalLossRate: 0,
+                totalYieldEarned: 0,
+            };
+            for (const poolOverview of poolOverviews) {
+                retn.totalValueLocked += parseFloat(poolOverview.totalValueLocked.total);
+                retn.loansUnderManagement += parseFloat(poolOverview.loansUnderManagement);
+                retn.totalLoanFundsOriginated += parseFloat(poolOverview.loanFundsOriginated);
+                retn.totalYieldEarned += parseFloat(poolOverview.yieldEarned);
+            }
+            for (const poolOverview of poolOverviews) {
+                const riskManagement = riskManagements.find((rm) => rm.poolIdFK.toLowerCase() === poolOverview.id.toLowerCase());
+                if (!riskManagement) {
+                    console.warn("Couldn't find risk management for id: ", poolOverview.id);
+                    continue;
+                }
+                const weight = retn.totalLoanFundsOriginated === 0
+                    ? 0
+                    : parseFloat(poolOverview.loanFundsOriginated) /
+                        retn.totalLoanFundsOriginated;
+                retn.totalLossRate +=
+                    riskManagement.riskPerformance.poolLossRate * weight;
+            }
+            return retn;
+        });
+    }
+    calculateCompounding(amount, epochInterestRate, daysInvested, interestFee) {
+        const COMPOUNDING_PERIOD = 7;
+        const earnedAmount = [];
+        const epochInterestRateAfterFee = epochInterestRate * (1 - interestFee);
+        for (let i = 0; i < daysInvested + 1; i++) {
+            const investmentEpochs = i / COMPOUNDING_PERIOD;
+            const interestEarned = amount *
+                (Math.pow(1 + epochInterestRateAfterFee, investmentEpochs) - 1);
+            earnedAmount.push(interestEarned);
+        }
+        return earnedAmount;
+    }
+    calculateBonusInterestEarnings(earnedAmounts, amount, bonusEpochInterest) {
+        const COMPOUNDING_PERIOD = 7;
+        const dailyInterest = bonusEpochInterest / COMPOUNDING_PERIOD;
+        const bonusInterestEarned = [0];
+        for (let i = 1; i < earnedAmounts.length; i++) {
+            const bonusInterest = (amount + earnedAmounts[i]) * dailyInterest;
+            bonusInterestEarned.push(bonusInterestEarned[i - 1] + bonusInterest);
+        }
+        return bonusInterestEarned;
+    }
+}