@kasufinance/kasu-sdk 1.0.1

package/dist/services/Portfolio/portfolio.js

@@ -0,0 +1,325 @@
+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());
+    });
+};
+import { BigNumber } from 'ethers';
+import { formatEther, parseEther, parseUnits } from 'ethers/lib/utils';
+import { GraphQLClient } from 'graphql-request';
+import { IKasuNFTsAbi__factory, ISystemVariablesAbi__factory, } from '../../contracts';
+import { DataService } from '../DataService/data-service';
+import { KSULocking } from '../Locking/locking';
+import { UserLending } from '../UserLending/user-lending';
+import { lendingPortfolioQuery } from './queries';
+export class Portfolio {
+    constructor(_kasuConfig, signerOrProvider) {
+        this._kasuConfig = _kasuConfig;
+        this._signerOrProvider = signerOrProvider;
+        this._lockingService = new KSULocking(_kasuConfig, signerOrProvider);
+        this._dataService = new DataService(_kasuConfig, signerOrProvider);
+        this._systemVariablesAbi = ISystemVariablesAbi__factory.connect(_kasuConfig.contracts.SystemVariables, signerOrProvider);
+        this._userLendingService = new UserLending(_kasuConfig, signerOrProvider);
+        this._kasuNftContract = IKasuNFTsAbi__factory.connect(_kasuConfig.contracts.KasuNFTs, signerOrProvider);
+        this._graph = new GraphQLClient(_kasuConfig.subgraphUrl);
+    }
+    getPortfolioRewards(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userLockingData = yield this._lockingService.getUserBonusData(userAddress);
+            const lockingRewards = yield this._lockingService.getLockingRewards(userAddress);
+            const ksuLaunchBonus = yield this._lockingService.getUserTotalBonusAmount(userAddress);
+            return {
+                bonusYieldEarnings: {
+                    claimableBalance: {
+                        ksuAmount: userLockingData.ksuBonusAndRewards,
+                    },
+                    lifeTime: {
+                        ksuAmount: userLockingData.ksuBonusAndRewardsLifetime,
+                    },
+                },
+                protocolFees: {
+                    claimableBalance: {
+                        usdcAmount: lockingRewards.claimableRewards,
+                    },
+                    lifeTime: { usdcAmount: lockingRewards.lifeTimeRewards },
+                },
+                ksuLaunchBonus: { lifeTime: { ksuAmount: ksuLaunchBonus } },
+            };
+        });
+    }
+    getUserNfts(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const usernfts = yield this._kasuNftContract.tokensOfOwner(userAddress);
+            return usernfts.map((nft) => nft.toNumber());
+        });
+    }
+    getPortfolioSummary(userAddress, portfolioLendingPools) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userLockingData = yield this._lockingService.getUserBonusData(userAddress);
+            let totalInvestments = 0;
+            let weightedApy = 0;
+            let totalYieldEarned = 0;
+            let weeklyYieldEarnings = 0;
+            for (const pool of portfolioLendingPools) {
+                for (const tranche of pool.tranches) {
+                    const investedAmount = parseFloat(tranche.investedAmount);
+                    totalInvestments += investedAmount;
+                    totalYieldEarned += parseFloat(tranche.yieldEarnings.lifetime);
+                    weightedApy += parseFloat(tranche.apy) * investedAmount;
+                    weeklyYieldEarnings +=
+                        investedAmount * parseFloat(tranche.interestRate);
+                    for (const fixedDeposits of tranche.fixedLoans) {
+                        const ftdConfig = tranche.fixedTermConfig.find((ftd) => ftd.configId === fixedDeposits.configId);
+                        if (!ftdConfig)
+                            continue;
+                        const ftdInvestedAmount = parseFloat(fixedDeposits.amount);
+                        totalInvestments += ftdInvestedAmount;
+                        totalYieldEarned += parseFloat(fixedDeposits.yieldEarnings.lifetime);
+                        weeklyYieldEarnings +=
+                            ftdInvestedAmount *
+                                parseFloat(ftdConfig.epochInterestRate);
+                        weightedApy +=
+                            parseFloat(ftdConfig.apy) * ftdInvestedAmount;
+                    }
+                }
+            }
+            return {
+                current: {
+                    totalKsuLocked: userLockingData.totalLockedAmount,
+                    totalLendingPoolInvestments: totalInvestments.toString(),
+                    weightedAverageApy: totalInvestments === 0
+                        ? '0'
+                        : (weightedApy / totalInvestments).toString(),
+                },
+                daily: {
+                    yieldEarnings: (weeklyYieldEarnings / 7).toString(),
+                },
+                weekly: {
+                    yieldEarnings: weeklyYieldEarnings.toString(),
+                    protocolFeesEarned: '0',
+                    ksuBonusRewards: '0',
+                },
+                lifetime: {
+                    yieldEarnings: totalYieldEarned.toString(),
+                    ksuBonusRewards: userLockingData.ksuBonusAndRewards,
+                    protocolFeesEarned: userLockingData.protocolFeesEarned,
+                },
+            };
+        });
+    }
+    getPortfolioLendingData(userAddress, poolOverviews, currentEpoch, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            const SECONDS_PER_EPOCH = 604800; // seconds in a week
+            const portfolioLendingPoolsPromise = [];
+            const previousEpoch = BigNumber.from(currentEpoch).sub(BigNumber.from(1));
+            const [lastEpochData, portfolioUserTrancheBalances, userPoolBalances] = yield Promise.all([
+                this._graph.request(lendingPortfolioQuery, {
+                    userAddress: userAddress.toLowerCase(),
+                    epochId: parseFloat(currentEpoch),
+                    lastEpochId: previousEpoch.toNumber(),
+                    unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
+                }),
+                this._userLendingService.getPortfolioUserTrancheBalances(userAddress),
+                this._userLendingService.getUserPoolBalance(userAddress, poolOverviews.map(({ id }) => id), provider),
+            ]);
+            if (!lastEpochData.user)
+                return [];
+            const userRequestsMap = new Map();
+            for (const userRequest of lastEpochData.userRequests) {
+                const trancheId = userRequest.tranche.id;
+                const ftdId = userRequest.fixedTermConfigId;
+                let remainingAcceptedAmount = parseFloat(userRequest.amountAccepted);
+                for (const userRequestEvent of userRequest.userRequestEvents) {
+                    const mappedUserRequest = userRequestsMap.get(trancheId);
+                    const assetAmount = parseFloat(userRequestEvent.assetAmount);
+                    const acceptedAmount = remainingAcceptedAmount > assetAmount
+                        ? assetAmount
+                        : remainingAcceptedAmount;
+                    remainingAcceptedAmount -= acceptedAmount;
+                    const userRequestFtdItem = {
+                        id: userRequestEvent.id,
+                        depositAmount: userRequestEvent.assetAmount,
+                        acceptedAmount: acceptedAmount.toString(),
+                        timestamp: parseInt(userRequest.createdOn),
+                    };
+                    if (!mappedUserRequest) {
+                        userRequestsMap.set(trancheId, {
+                            [ftdId]: [userRequestFtdItem],
+                        });
+                        continue;
+                    }
+                    userRequestsMap.set(trancheId, Object.assign(Object.assign({}, mappedUserRequest), { [ftdId]: [
+                            ...((_a = mappedUserRequest[ftdId]) !== null && _a !== void 0 ? _a : []),
+                            userRequestFtdItem,
+                        ] }));
+                }
+            }
+            let totalInvestments = BigNumber.from(0);
+            let totalYieldEarnedLastEpoch = 0;
+            for (const poolOverview of poolOverviews) {
+                const userPoolBalance = userPoolBalances.find(({ poolId }) => poolId === poolOverview.id);
+                if (!userPoolBalance) {
+                    console.warn(`Could not find user pool balance for ${poolOverview.id}`);
+                    continue;
+                }
+                totalInvestments = userPoolBalance.balance.add(totalInvestments);
+                const tranches = [];
+                const lendingPoolUserDetails = lastEpochData.user.lendingPoolUserDetails.find(({ lendingPool }) => lendingPool.id === poolOverview.id);
+                if (!lendingPoolUserDetails)
+                    continue;
+                const portfolioUserTrancheBalance = portfolioUserTrancheBalances.get(poolOverview.id);
+                for (const tranche of poolOverview.tranches) {
+                    const lastEpochUserTrancheDetails = lendingPoolUserDetails.lendingPoolTrancheUserDetails.find((lendingPool) => lendingPool.tranche.id === tranche.id);
+                    const userRequest = userRequestsMap.get(tranche.id);
+                    const depositDetails = (_b = userRequest === null || userRequest === void 0 ? void 0 : userRequest['0']) !== null && _b !== void 0 ? _b : [];
+                    if (!lastEpochUserTrancheDetails) {
+                        tranches.push(Object.assign(Object.assign({}, tranche), { investedAmount: {
+                                balance: '0',
+                                yieldEarned: 0,
+                            }, yieldEarnings: {
+                                lastEpoch: '0',
+                                lifetime: '0',
+                            }, depositDetails, fixedLoans: [] }));
+                        continue;
+                    }
+                    const lastEpochTotalYield = parseFloat((_e = (_d = (_c = lastEpochUserTrancheDetails.tranche
+                        .lendingPoolTrancheEpochInterest) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.epochInterestAmount) !== null && _e !== void 0 ? _e : '0');
+                    const lastEpochUserShares = parseFloat((_h = (_g = (_f = lastEpochUserTrancheDetails
+                        .lendingPoolTrancheUserEpochSharesUpdates) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.shares) !== null && _h !== void 0 ? _h : '0');
+                    const lastEpochTotalShares = parseFloat((_l = (_k = (_j = lastEpochUserTrancheDetails.tranche
+                        .lendingPoolTrancheShareUpdates) === null || _j === void 0 ? void 0 : _j[0]) === null || _k === void 0 ? void 0 : _k.shares) !== null && _l !== void 0 ? _l : '0');
+                    const currentTotalAmount = parseFloat(lastEpochUserTrancheDetails.tranche.balance);
+                    const currentTotalShares = parseFloat(lastEpochUserTrancheDetails.tranche.shares);
+                    const lastEpochTotalBaseYield = lastEpochTotalShares === 0
+                        ? 0
+                        : (lastEpochTotalYield * lastEpochUserShares) /
+                            lastEpochTotalShares;
+                    const userTrancheBalance = {
+                        balance: '0',
+                        yieldEarned: 0,
+                    };
+                    if (portfolioUserTrancheBalance) {
+                        const portfolioUserTranche = portfolioUserTrancheBalance.find(({ trancheId }) => trancheId === tranche.id);
+                        if (portfolioUserTranche) {
+                            userTrancheBalance.balance =
+                                portfolioUserTranche.userBalance;
+                            userTrancheBalance.yieldEarned =
+                                portfolioUserTranche.yieldEarned;
+                        }
+                    }
+                    let totalLifetimeFtdYield = 0;
+                    let lastEpochVariableBaseYield = lastEpochTotalBaseYield;
+                    const fixedLoans = lastEpochUserTrancheDetails.userLendingPoolTrancheFixedTermDepositLocks.map((fixedTermDeposit) => {
+                        var _a, _b, _c, _d, _e;
+                        const fixedLoanDepositDetails = (_a = userRequest === null || userRequest === void 0 ? void 0 : userRequest[fixedTermDeposit
+                            .lendingPoolTrancheFixedTermConfig
+                            .configId]) !== null && _a !== void 0 ? _a : [];
+                        let lastEpochYieldEarned = 0;
+                        let lifetimeYieldEarned = 0;
+                        if (parseFloat(fixedTermDeposit.epochLockStart) <
+                            previousEpoch.toNumber() &&
+                            parseFloat(fixedTermDeposit.epochLockEnd) >=
+                                previousEpoch.toNumber() &&
+                            Boolean((_b = lastEpochUserTrancheDetails
+                                .lendingPoolTrancheUserEpochSharesUpdates) === null || _b === void 0 ? void 0 : _b.length)) {
+                            const currentEpochFtdShares = parseFloat(fixedTermDeposit.trancheShares);
+                            const lastEpochFtdShares = parseFloat((_e = (_d = (_c = fixedTermDeposit
+                                .userLendingPoolTrancheFixedTermDepositLockShareUpdate) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.shares) !== null && _e !== void 0 ? _e : '0');
+                            const additionalFtdYield = ((currentEpochFtdShares -
+                                lastEpochFtdShares) *
+                                currentTotalAmount) /
+                                currentTotalShares;
+                            const lastEpochFtdBaseYield = (lastEpochTotalBaseYield *
+                                lastEpochFtdShares) /
+                                lastEpochUserShares;
+                            lastEpochVariableBaseYield -=
+                                lastEpochFtdBaseYield;
+                            lastEpochYieldEarned =
+                                lastEpochFtdBaseYield + additionalFtdYield;
+                        }
+                        lifetimeYieldEarned =
+                            this.calculateFixedTermDepositEarnings(fixedTermDeposit, lastEpochUserTrancheDetails.tranche.balance, lastEpochUserTrancheDetails.tranche.shares);
+                        totalLifetimeFtdYield += lifetimeYieldEarned;
+                        totalYieldEarnedLastEpoch += lastEpochYieldEarned;
+                        const lockDuration = parseFloat(fixedTermDeposit
+                            .lendingPoolTrancheFixedTermConfig
+                            .epochLockDuration) * SECONDS_PER_EPOCH;
+                        return {
+                            lockId: fixedTermDeposit.lockId,
+                            configId: fixedTermDeposit
+                                .lendingPoolTrancheFixedTermConfig
+                                .configId,
+                            epochLockDuration: fixedTermDeposit
+                                .lendingPoolTrancheFixedTermConfig
+                                .epochLockDuration,
+                            epochLockEnd: fixedTermDeposit.epochLockEnd,
+                            epochInterestRate: fixedTermDeposit
+                                .lendingPoolTrancheFixedTermConfig
+                                .epochInterestRate,
+                            epochLockStart: fixedTermDeposit.epochLockStart,
+                            amount: this._userLendingService
+                                .convertSharesToAssets(fixedTermDeposit.trancheShares, lastEpochUserTrancheDetails.tranche
+                                .balance, lastEpochUserTrancheDetails.tranche
+                                .shares)
+                                .toString(),
+                            endTime: parseInt(fixedTermDeposit.createdOn) +
+                                lockDuration,
+                            isLocked: fixedTermDeposit.isLocked,
+                            isWithdrawalRequested: fixedTermDeposit.isWithdrawalRequested,
+                            startTime: parseInt(fixedTermDeposit.createdOn),
+                            yieldEarnings: {
+                                lastEpoch: lastEpochYieldEarned.toString(),
+                                lifetime: this.precisionToString(lifetimeYieldEarned),
+                            },
+                            depositDetails: fixedLoanDepositDetails,
+                        };
+                    });
+                    totalYieldEarnedLastEpoch += lastEpochTotalBaseYield;
+                    tranches.push(Object.assign(Object.assign({}, tranche), { investedAmount: userTrancheBalance, yieldEarnings: {
+                            lastEpoch: lastEpochVariableBaseYield.toString(),
+                            lifetime: this.precisionToString(totalLifetimeFtdYield), // passing in total FTD yield to be subtracted by total trache lifetime later down
+                        }, fixedLoans,
+                        depositDetails }));
+                }
+                portfolioLendingPoolsPromise.push(Object.assign(Object.assign({}, poolOverview), { totalYieldEarningsLastEpoch: totalYieldEarnedLastEpoch.toString(), totalInvestedAmount: userPoolBalance.balance.toString(), totalYieldEarningsLifetime: userPoolBalance.yieldEarned.toString(), tranches }));
+            }
+            const portfolioLendingPools = portfolioLendingPoolsPromise.map((pool) => (Object.assign(Object.assign({}, pool), { tranches: pool.tranches.map((tranche) => {
+                    const trancheBalance = tranche.investedAmount;
+                    const lockedAmount = tranche.fixedLoans.reduce((total, cur) => {
+                        if (!cur.isLocked)
+                            return total;
+                        return total.add(parseEther(cur.amount));
+                    }, BigNumber.from(0));
+                    const totalTrancheYieldEarned = trancheBalance.yieldEarned.toFixed(6);
+                    const totalTrancheFtdYieldEarned = parseFloat(tranche.yieldEarnings.lifetime).toFixed(6);
+                    return Object.assign(Object.assign({}, tranche), { investedAmount: formatEther(parseEther(trancheBalance.balance).sub(lockedAmount)), yieldEarnings: Object.assign(Object.assign({}, tranche.yieldEarnings), { lifetime: this.precisionToString(parseFloat(totalTrancheYieldEarned) -
+                                parseFloat(totalTrancheFtdYieldEarned)) }) });
+                }) })));
+            return portfolioLendingPools.filter((pool) => !parseUnits(pool.totalInvestedAmount).isZero() ||
+                !parseUnits(pool.totalYieldEarningsLifetime).isZero());
+        });
+    }
+    precisionToString(val) {
+        if (val < 0 && val > -0.0001) {
+            return '0';
+        }
+        return val.toString();
+    }
+    calculateFixedTermDepositEarnings(fixedTermDepositLock, totalTrancheBalance, totalTrancheShares) {
+        const { isLocked, unlockAmount, initialAmount, trancheShares } = fixedTermDepositLock;
+        let yieldEarned = 0;
+        if (!isLocked && unlockAmount) {
+            yieldEarned = parseFloat(unlockAmount) - parseFloat(initialAmount);
+        }
+        else {
+            const currentUsdAmount = this._userLendingService.convertSharesToAssets(trancheShares, totalTrancheBalance, totalTrancheShares);
+            yieldEarned =
+                parseFloat(currentUsdAmount) - parseFloat(initialAmount);
+        }
+        return yieldEarned;
+    }
+}

package/dist/services/Portfolio/queries.d.ts

@@ -0,0 +1,2 @@
+export declare const lastEpochQuery: string;
+export declare const lendingPortfolioQuery: string;

package/dist/services/Portfolio/queries.js

@@ -0,0 +1,164 @@
+import { gql } from 'graphql-request';
+export const lastEpochQuery = gql `
+    query LastEpochQuery(
+        $userAddress: String!
+        $epochId: String!
+        $unusedPools: [String]!
+    ) {
+        user(id: $userAddress) {
+            lendingPoolUserDetails(
+                where: { lendingPool_not_in: $unusedPools }
+            ) {
+                id
+                lendingPool {
+                    id
+                    name
+                    balance
+                    tranches {
+                        shares
+                    }
+                }
+                lendingPoolTrancheUserDetails {
+                    lendingPoolTrancheUserEpochSharesUpdates(
+                        orderDirection: desc
+                        orderBy: shareUpdatesIndex
+                        where: { epochId_lte: $epochId }
+                        first: 1
+                    ) {
+                        shares
+                    }
+                    userLendingPoolTrancheFixedTermDepositLocks {
+                        lockId
+                        initialTrancheShares
+                        isWithdrawalRequested
+                        createdOn
+                        epochLockStart
+                        epochLockEnd
+                        lendingPoolTrancheFixedTermConfig {
+                            epochLockDuration
+                        }
+                    }
+                    tranche {
+                        id
+                        lendingPoolTrancheShareUpdates(
+                            orderBy: shareUpdatesIndex
+                            orderDirection: desc
+                            where: { epochId_lte: $epochId }
+                            first: 1
+                        ) {
+                            shares
+                        }
+                        lendingPoolTrancheEpochInterest(
+                            where: { epochId: $epochId }
+                        ) {
+                            epochInterestAmount
+                        }
+                    }
+                }
+            }
+        }
+    }
+`;
+export const lendingPortfolioQuery = gql `
+    query LastEpochQuery(
+        $userAddress: ID!
+        $epochId: BigInt!
+        $lastEpochId: BigInt!
+        $unusedPools: [String!]!
+    ) {
+        user(id: $userAddress) {
+            lendingPoolUserDetails(
+                where: { lendingPool_not_in: $unusedPools }
+            ) {
+                id
+                lendingPool {
+                    id
+                    name
+                    balance
+                    tranches {
+                        shares
+                    }
+                }
+                lendingPoolTrancheUserDetails {
+                    shares
+                    lendingPoolTrancheUserEpochSharesUpdates(
+                        orderDirection: desc
+                        orderBy: shareUpdatesIndex
+                        where: { epochId_lt: $epochId }
+                        first: 1
+                    ) {
+                        shares
+                    }
+                    userLendingPoolTrancheFixedTermDepositLocks {
+                        isLocked
+                        unlockAmount
+                        initialAmount
+                        lockId
+                        initialTrancheShares
+                        isWithdrawalRequested
+                        createdOn
+                        epochLockStart
+                        epochLockEnd
+                        trancheShares
+                        lendingPoolTrancheFixedTermConfig {
+                            epochLockDuration
+                            configId
+                            epochInterestRate
+                        }
+                        userLendingPoolTrancheFixedTermDepositLockShareUpdate(
+                            orderBy: shareUpdatesIndex
+                            orderDirection: desc
+                            first: 1
+                            where: { epochId_lt: $lastEpochId }
+                        ) {
+                            shares
+                        }
+                    }
+                    tranche {
+                        id
+                        shares
+                        balance
+                        lendingPoolTrancheShareUpdates(
+                            first: 1
+                            orderBy: shareUpdatesIndex
+                            orderDirection: desc
+                            where: { epochId_lt: $epochId }
+                        ) {
+                            shares
+                        }
+                        lendingPoolTrancheEpochInterest(
+                            first: 1
+                            orderBy: epochId
+                            orderDirection: desc
+                            where: { epochId_lt: $epochId }
+                        ) {
+                            epochInterestAmount
+                        }
+                    }
+                }
+            }
+        }
+        userRequests(
+            where: {
+                user: $userAddress
+                userRequestEvents_: {
+                    type_in: [DepositInitiated, DepositIncreased]
+                    additionalData_not: null
+                }
+            }
+        ) {
+            createdOn
+            amountAccepted
+            tranche {
+                id
+            }
+            fixedTermConfigId
+            userRequestEvents(
+                where: { type_in: [DepositInitiated, DepositIncreased] }
+            ) {
+                id
+                assetAmount
+            }
+        }
+    }
+`;