@kasufinance/kasu-sdk 1.0.1

package/dist/services/Locking/locking.js

@@ -0,0 +1,344 @@
+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, ethers } from 'ethers';
+import { formatEther, formatUnits, parseUnits } from 'ethers/lib/utils';
+import { GraphQLClient } from 'graphql-request';
+import { IERC20MetadataAbi__factory, IKSULockingAbi__factory, IKsuPriceAbi__factory, ISystemVariablesAbi__factory, IUserLoyaltyRewardsAbi__factory, IUserManagerAbi__factory, } from '../../contracts';
+import { getAllTrancheConfigurationsQuery, getAllTranchesQuery, } from '../DataService/queries';
+import { claimedFeesQuery, getSystemVariablesQuery, getTotalUserLoyaltsRewardsQuery, lockingPeriodsQuery, lockingSummariesQuery, userEarnedrKsuQuery, userLocksQuery, userStakedKsuQuery, userTotalBonusAmountQuery, } from './queries';
+export class KSULocking {
+    /**
+     *
+     */
+    constructor(_kasuConfig, signerOrProvider) {
+        this._kasuConfig = _kasuConfig;
+        this.apyBonuses = [0, 0.001, 0.002];
+        this._contractAbi = IKSULockingAbi__factory.connect(_kasuConfig.contracts.IKSULocking, signerOrProvider);
+        this._kasuToken = IERC20MetadataAbi__factory.connect(_kasuConfig.contracts.KSUToken, signerOrProvider);
+        this._userManagerAbi = IUserManagerAbi__factory.connect(_kasuConfig.contracts.UserManager, signerOrProvider);
+        this._systemVariablesAbi = ISystemVariablesAbi__factory.connect(_kasuConfig.contracts.SystemVariables, signerOrProvider);
+        this._ksuPriceAbi = IKsuPriceAbi__factory.connect(_kasuConfig.contracts.KsuPrice, signerOrProvider);
+        this._kasuBonusAddress = _kasuConfig.contracts.IKSULockBonus;
+        this._graph = new GraphQLClient(_kasuConfig.subgraphUrl);
+        this._userLoyaltyRewardsAbi = IUserLoyaltyRewardsAbi__factory.connect(_kasuConfig.contracts.UserLoyaltyRewards, signerOrProvider);
+    }
+    lockKSUTokens(amount, lockPeriod) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._contractAbi.lock(amount, lockPeriod);
+        });
+    }
+    lockKSUWithPermit(amount, lockPeriod, permit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const amountBN = BigNumber.from(amount);
+            const lockPeriodBN = BigNumber.from(lockPeriod);
+            const ksuPermit = {
+                value: BigNumber.from(permit.value),
+                deadline: BigNumber.from(permit.deadline),
+                v: BigNumber.from(permit.v),
+                r: permit.r,
+                s: permit.s,
+            };
+            return this._contractAbi.lockWithPermit(amountBN, lockPeriodBN, ksuPermit);
+        });
+    }
+    unlockKSU(amount, userLockId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._contractAbi.unlock(amount, userLockId);
+        });
+    }
+    claimFees() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._contractAbi.claimFees();
+        });
+    }
+    lockDetails(lockPeriod) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._contractAbi.lockDetails(lockPeriod);
+            return {
+                rKsuMultiplier: result[0].toNumber(),
+                ksuBonusMultiplier: result[1].toNumber(),
+                isActive: result[2],
+            };
+        });
+    }
+    userTotalDeposits(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._contractAbi.userTotalDeposits(userAddress);
+        });
+    }
+    calculateUserLockProjectedProtocolFeeRewards(epochId, KSULocked, lockPeriod) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (KSULocked === 0) {
+                return 0;
+            }
+            const lockingSummarySubgraph = yield this._graph.request(lockingSummariesQuery);
+            const lockingSummary = lockingSummarySubgraph.lockingSummaries[0];
+            const totalRKSU = lockingSummary.totalRKsuAmount;
+            const lockDetails = yield this.lockDetails(lockPeriod);
+            const newUserRKSU = (KSULocked + KSULocked * lockDetails.ksuBonusMultiplier) *
+                lockDetails.rKsuMultiplier;
+            const totalRKSUAfterLock = totalRKSU + newUserRKSU;
+            const systemVariables = yield this._graph.request(getSystemVariablesQuery);
+            const performanceFee = parseFloat(systemVariables.systemVariables.performanceFee) / 100;
+            const ecosystemFee = parseFloat(systemVariables.systemVariables.ecosystemFeeRate) / 100;
+            let projectedYearlyPlatformInterest = 0;
+            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,
+            });
+            for (const tranche of subgraphResults.lendingPoolTranches) {
+                const trancheConfig = subgraphConfigurationResults.lendingPoolTrancheConfigurations.find((r) => r.id == tranche.id);
+                if (!trancheConfig) {
+                    console.warn("Couldn't find tranche configuration for id: ", tranche.id);
+                    continue;
+                }
+                const interestUpdates = trancheConfig.lendingPoolTrancheInterestRateUpdates;
+                const interestRate = interestUpdates.length
+                    ? interestUpdates[0].epochInterestRate
+                    : trancheConfig.interestRate;
+                projectedYearlyPlatformInterest +=
+                    parseFloat(tranche.balance) *
+                        this.calculateApy(parseFloat(interestRate));
+            }
+            const totalExpectedEcosystemFees = projectedYearlyPlatformInterest * performanceFee * ecosystemFee;
+            return ((totalExpectedEcosystemFees * newUserRKSU) /
+                parseFloat(totalRKSUAfterLock));
+        });
+    }
+    calculateApy(epochInterestRate) {
+        const EPOCHS_IN_YEAR = 52.17857;
+        return (1 + epochInterestRate) ^ (EPOCHS_IN_YEAR - 1);
+    }
+    getUserLocks(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._graph.request(userLocksQuery, {
+                userAddress: userAddress.toLowerCase(),
+            });
+            const resultPromises = result.userLocks.map((userLock) => __awaiter(this, void 0, void 0, function* () {
+                const [, id] = userLock.id.split('-');
+                const rKSUtoUSDCRatio = yield this.getRKSUvsUSDCRatio(userLock.rKSUAmount, userAddress);
+                const loyaltyStatus = this.getLoyaltyLevelAndApyBonusFromRatio(rKSUtoUSDCRatio);
+                return {
+                    id: BigNumber.from(id),
+                    lockedAmount: userLock.ksuAmount,
+                    rKSUAmount: userLock.rKSUAmount,
+                    rKSUtoUSDCRatio: rKSUtoUSDCRatio,
+                    apyBonus: loyaltyStatus.apyBonus,
+                    loyaltyLevel: loyaltyStatus.loyaltyLevel,
+                    startTime: parseFloat(userLock.startTimestamp),
+                    endTime: parseFloat(userLock.endTimestamp),
+                    lockPeriod: userLock.lockPeriod,
+                };
+            }));
+            const results = yield Promise.all(resultPromises);
+            return results.sort((a, b) => a.endTime - b.endTime);
+        });
+    }
+    getUserBonusData(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO this userLocks query is kinda bad -> change to userLocksDepositInfo as u never need user locks by themselves
+            // whole function takes between 500 - 800ms
+            const DECIMALS = 18;
+            // Normalized user address
+            const normalizedAddress = userAddress.toLowerCase();
+            // Fetch data concurrently
+            const [userLocksData, resultLoyaltyRewards, protocolFeesEarned, userRewards,] = yield Promise.all([
+                this._graph.request(userLocksQuery, {
+                    userAddress: normalizedAddress,
+                }),
+                this._graph.request(getTotalUserLoyaltsRewardsQuery, { userAddress: normalizedAddress }),
+                this._contractAbi.rewards(userAddress),
+                this._userLoyaltyRewardsAbi.userRewards(userAddress),
+            ]);
+            // Extract data and format with fallback
+            const { userLocks } = userLocksData;
+            const formattedKsuBonusAndRewards = ethers.utils.formatUnits(userRewards, DECIMALS);
+            const formattedProtocolFeesEarned = ethers.utils.formatUnits(protocolFeesEarned, DECIMALS);
+            const ksuBonusAndRewardsLifetime = resultLoyaltyRewards.user === null
+                ? '0.0'
+                : resultLoyaltyRewards.user.totalUserLoyaltyRewards;
+            const totalLockedAmount = userLocks.length === 0
+                ? '0.0'
+                : userLocks[0].userLockDepositsInfo.ksuLockedAmount;
+            // Construct response data
+            return {
+                ksuBonusAndRewards: formattedKsuBonusAndRewards,
+                ksuBonusAndRewardsLifetime: ksuBonusAndRewardsLifetime,
+                protocolFeesEarned: formattedProtocolFeesEarned,
+                totalLockedAmount: totalLockedAmount,
+            };
+        });
+    }
+    getLoyaltyLevelAndApyBonusFromRatio(rKSUtoUSDCRatio) {
+        if (rKSUtoUSDCRatio < 0.01) {
+            return { loyaltyLevel: 0, apyBonus: this.apyBonuses[0] };
+        }
+        else if (rKSUtoUSDCRatio < 0.05) {
+            return { loyaltyLevel: 1, apyBonus: this.apyBonuses[1] };
+        }
+        return { loyaltyLevel: 2, apyBonus: this.apyBonuses[2] };
+    }
+    getRKSUvsUSDCRatio(rKSUAmount, userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [depositedAmount, pendingAmount] = yield this._userManagerAbi.userTotalPendingAndActiveDepositedAmountForCurrentEpoch(userAddress);
+            const ksuPrice = yield this._systemVariablesAbi.ksuEpochTokenPrice();
+            const rKSUAmountBignumber = ethers.utils.parseUnits(rKSUAmount, 18);
+            const totalUserUsdcAmount = depositedAmount.toNumber() + pendingAmount.toNumber();
+            const rKSUInUSDC = rKSUAmountBignumber
+                .mul(ksuPrice)
+                .div(ethers.utils.parseUnits('1', 18))
+                .div(ethers.utils.parseUnits('1', 12));
+            return rKSUInUSDC.toNumber() / totalUserUsdcAmount;
+        });
+    }
+    getClaimableRewards(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._contractAbi.rewards(userAddress);
+            return result;
+        });
+    }
+    getKasuTokenPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const decimals = 18;
+            return Promise.resolve({
+                price: yield this._ksuPriceAbi.ksuTokenPrice(),
+                decimals,
+            });
+        });
+    }
+    getKasuEpochTokenPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const decimals = 18;
+            return Promise.resolve({
+                price: yield this._systemVariablesAbi.ksuEpochTokenPrice(),
+                decimals,
+            });
+        });
+    }
+    getLifetimeRewards(userAddress, rewardDecimals, claimableRewards) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const result = yield this._graph.request(claimedFeesQuery, {
+                userAddress: userAddress.toLowerCase(),
+            });
+            const claimedRewards = (_b = (_a = result.userLockDepositsInfo) === null || _a === void 0 ? void 0 : _a.feesClaimed) !== null && _b !== void 0 ? _b : '0';
+            if (!claimableRewards) {
+                claimableRewards = yield this.getClaimableRewards(userAddress);
+            }
+            return claimableRewards.add(parseUnits(claimedRewards, rewardDecimals));
+        });
+    }
+    getLaunchBonusAmount(lockAmount, bonusMultiplier, bonusTokensLeft) {
+        const bonusMultiplierBN = ethers.utils.parseUnits(bonusMultiplier.toFixed(2), 2);
+        const projectedBonus = lockAmount.mul(bonusMultiplierBN).div(100);
+        if (bonusTokensLeft.gt(projectedBonus)) {
+            return projectedBonus;
+        }
+        else {
+            return bonusTokensLeft;
+        }
+    }
+    getUserStakedKsu(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._graph.request(userStakedKsuQuery, {
+                userAddress: userAddress.toLowerCase(),
+            });
+            if (result.userLockDepositsInfo == null) {
+                return '0';
+            }
+            return result.userLockDepositsInfo.ksuLockedAmount;
+        });
+    }
+    getUserEarnedrKsu(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._graph.request(userEarnedrKsuQuery, {
+                userAddress: userAddress.toLowerCase(),
+            });
+            if (result.userLockDepositsInfo == null) {
+                return '0';
+            }
+            return result.userLockDepositsInfo.rKSUAmount;
+        });
+    }
+    getUserTotalBonusAmount(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._graph.request(userTotalBonusAmountQuery, {
+                userAddress: userAddress.toLowerCase(),
+            });
+            if (result.userLockDepositsInfo == null) {
+                return '0';
+            }
+            return result.userLockDepositsInfo.totalKsuBonusAmount;
+        });
+    }
+    getLockingRewards(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rewardDecimals = 6;
+            const claimableRewards = yield this.getClaimableRewards(userAddress);
+            const lifeTimeRewards = yield this.getLifetimeRewards(userAddress, rewardDecimals, claimableRewards);
+            return {
+                claimableRewards: formatUnits(claimableRewards, rewardDecimals),
+                lifeTimeRewards: formatUnits(lifeTimeRewards, rewardDecimals),
+            };
+        });
+    }
+    getTotalKsuStaked() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(ethers.constants.Zero.toString());
+        });
+    }
+    getAvailableKsuBonus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const amount = yield this._kasuToken.balanceOf(this._kasuBonusAddress);
+            return formatEther(amount);
+        });
+    }
+    getUserKsuBalance(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const balance = yield this._kasuToken.balanceOf(userAddress.toLowerCase());
+            return formatEther(balance);
+        });
+    }
+    getNextEpochDate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._systemVariablesAbi.nextEpochStartTimestamp()).toNumber();
+        });
+    }
+    getNextClearingPeriodDate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nextEpochDate = yield this.getNextEpochDate();
+            const clearingPeriodLength = yield this._systemVariablesAbi.clearingPeriodLength();
+            const nextClearingPeriod = BigNumber.from(nextEpochDate)
+                .sub(clearingPeriodLength)
+                .toNumber();
+            const nowUnix = Date.now() / 1000;
+            if (nowUnix >= nextClearingPeriod) {
+                const oneWeek = 604800; // in seconds
+                return nextClearingPeriod + oneWeek;
+            }
+            return nextClearingPeriod;
+        });
+    }
+    getActiveLockPeriods() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this._graph.request(lockingPeriodsQuery);
+            return data.lockPeriods;
+        });
+    }
+    getProjectedApy() {
+        return '10.00';
+    }
+    getProjectedUSDC() {
+        return '20.00';
+    }
+}

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

@@ -0,0 +1,10 @@
+export declare const claimedFeesQuery: string;
+export declare const userEarnedrKsuQuery: string;
+export declare const userTotalBonusAmountQuery: string;
+export declare const userStakedKsuQuery: string;
+export declare const userLocksQuery: string;
+export declare const lockingPeriodsQuery: string;
+export declare const lockingSummariesQuery: string;
+export declare const getAllTranchesQuery: string;
+export declare const getTotalUserLoyaltsRewardsQuery: string;
+export declare const getSystemVariablesQuery: string;

package/dist/services/Locking/queries.js

@@ -0,0 +1,108 @@
+import { gql } from 'graphql-request';
+export const claimedFeesQuery = gql `
+    query GetClaimedFeesForAddress($userAddress: String!) {
+        userLockDepositsInfo(id: $userAddress) {
+            feesClaimed
+        }
+    }
+`;
+export const userEarnedrKsuQuery = gql `
+    query GetClaimedFeesForAddress($userAddress: String!) {
+        userLockDepositsInfo(id: $userAddress) {
+            rKSUAmount
+        }
+    }
+`;
+export const userTotalBonusAmountQuery = gql `
+    query GetClaimedFeesForAddress($userAddress: String!) {
+        userLockDepositsInfo(id: $userAddress) {
+            totalKsuBonusAmount
+        }
+    }
+`;
+export const userStakedKsuQuery = gql `
+    query GetUserLockDepositsInfo($userAddress: String!) {
+        userLockDepositsInfo(id: $userAddress) {
+            ksuLockedAmount
+        }
+    }
+`;
+export const userLocksQuery = gql `
+    query GetUserLocks($userAddress: String!) {
+        userLocks(
+            where: { userLockDepositsInfo: $userAddress, ksuAmount_gt: 0 }
+        ) {
+            id
+            ksuAmount
+            endTimestamp
+            startTimestamp
+            lockPeriod {
+                rKSUMultiplier
+                lockPeriod
+                ksuBonusMultiplier
+                id
+            }
+            rKSUAmount
+            userLockDepositsInfo {
+                totalKsuBonusAmount
+                rKSUAmount
+                ksuLockedAmount
+                id
+                feesClaimed
+            }
+        }
+    }
+`;
+export const lockingPeriodsQuery = gql `
+    query LockingPeriodsQuery {
+        lockPeriods(orderBy: lockPeriod, where: { isActive: true }) {
+            rKSUMultiplier
+            lockPeriod
+            ksuBonusMultiplier
+            isActive
+            id
+        }
+    }
+`;
+export const lockingSummariesQuery = gql `
+    query LockingSummariesQuery {
+        lockingSummaries {
+            id
+            totalRKsuAmount
+            totalKsuLockedAmount
+            totalFeesEmitted
+        }
+    }
+`;
+export const getAllTranchesQuery = gql `
+    query getAllTranches($unusedPools: [String]!) {
+        lendingPoolTranches(where: { lendingPool_not_in: $unusedPools }) {
+            id
+            balance
+        }
+    }
+`;
+export const getTotalUserLoyaltsRewardsQuery = gql `
+    query getAllUserLoyaltsRewards($userAddress: String!) {
+        user(id: $userAddress) {
+            id
+            totalUserLoyaltyRewards
+        }
+    }
+`;
+export const getSystemVariablesQuery = gql `
+    query getSystemVariablesQuery {
+        systemVariables(id: "SYSTEM_VARIABLES") {
+            id
+            protocolFeeRate
+            priceUpdateEpoch
+            performanceFee
+            loyaltyThresholds
+            ksuEpochTokenPrice
+            epochDuration
+            ecosystemFeeRate
+            clearingPeriodLength
+            canOnlyDepositJuniorWhenUserHasRKSU
+        }
+    }
+`;

package/dist/services/Locking/types.d.ts

@@ -0,0 +1,117 @@
+import { BigNumber, Bytes } from 'ethers';
+export interface RSVDeadlineValue {
+    value: number;
+    deadline: number;
+    v: number;
+    r: Bytes;
+    s: Bytes;
+}
+export interface LockPeriodInterface {
+    rKsuMultiplier: number;
+    ksuBonusMultiplier: number;
+    isActive: boolean;
+}
+export interface LockPeriod {
+    rKSUMultiplier: string;
+    lockPeriod: string;
+    ksuBonusMultiplier: string;
+    id: string;
+}
+export interface UserLock {
+    id: BigNumber;
+    lockedAmount: string;
+    rKSUAmount: string;
+    rKSUtoUSDCRatio: number;
+    apyBonus: number;
+    startTime: EpochTimeStamp;
+    endTime: EpochTimeStamp;
+    lockPeriod: LockPeriod;
+}
+export interface UserBonusData {
+    ksuBonusAndRewards: string;
+    protocolFeesEarned: string;
+    ksuBonusAndRewardsLifetime: string;
+    totalLockedAmount: string;
+}
+export interface GQLGetLockingPeriods {
+    lockPeriods: LockPeriod[];
+}
+export interface GQLClaimedFeesForAddress {
+    userLockDepositsInfo: {
+        feesClaimed: string;
+    } | undefined;
+}
+export interface GQLStakedAmountForAddress {
+    userLockDepositsInfo: {
+        ksuLockedAmount: string;
+    } | undefined;
+}
+export interface GQLEarnedRKsuForAddress {
+    userLockDepositsInfo: {
+        rKSUAmount: string;
+    } | undefined;
+}
+export interface GQLTotalBonusAmountForAddress {
+    userLockDepositsInfo: {
+        totalKsuBonusAmount: string;
+    } | undefined;
+}
+export interface UserLockDepositsInfo {
+    feesClaimed: string;
+    ksuLockedAmount: string;
+    rKSUAmount: string;
+    totalKsuBonusAmount: string;
+    id: string;
+}
+export interface GQLUserLocks {
+    userLocks: {
+        id: string;
+        ksuAmount: string;
+        endTimestamp: string;
+        startTimestamp: string;
+        rKSUAmount: string;
+        lockPeriod: LockPeriod;
+        userLockDepositsInfo: UserLockDepositsInfo;
+    }[];
+}
+export interface LockingSummarySubgraphResult {
+    lockingSummaries: {
+        id: string;
+        totalRKsuAmount: string;
+        totalKsuLockedAmount: string;
+        totalFeesEmitted: string;
+    }[];
+}
+export interface TrancheConfigurationSubgraph {
+    lendingPoolTrancheConfigurations: {
+        id: string;
+        interestRate: string;
+    }[];
+}
+export interface TrancheSubgraph {
+    id: string;
+    balance: string;
+}
+export interface TrancheSubgraphResult {
+    lendingPoolTranches: TrancheSubgraph[];
+}
+export interface totalUserLoyaltyRewards {
+    user: {
+        id: string;
+        totalUserLoyaltyRewards: string;
+    } | null;
+}
+export interface SystemVariables {
+    systemVariables: {
+        id: string;
+        protocolFeeRate: string;
+        priceUpdateEpoch: string;
+        performanceFee: string;
+        loyaltyThresholds: string;
+        ksuEpochTokenPrice: string;
+        epochDuration: string;
+        ecosystemFeeRate: string;
+        clearingPeriodLength: string;
+        canOnlyDepositJuniorWhenUserHasRKSU: boolean;
+    };
+}

package/dist/services/Locking/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,22 @@
+import { Provider } from '@ethersproject/providers';
+import { Signer } from 'ethers';
+import { SdkConfig } from '../../sdk-config';
+import { PoolOverview } from '../DataService/types';
+import { PortfolioLendingPool, PortfolioRewards, PortfolioSummary, UserLendingPoolTrancheFixedTermDepositLock } from './types';
+export declare class Portfolio {
+    private _kasuConfig;
+    private _lockingService;
+    private _dataService;
+    private _userLendingService;
+    private readonly _graph;
+    private _systemVariablesAbi;
+    private _kasuNftContract;
+    readonly _signerOrProvider: Signer | Provider;
+    constructor(_kasuConfig: SdkConfig, signerOrProvider: Signer | Provider);
+    getPortfolioRewards(userAddress: string): Promise<PortfolioRewards>;
+    getUserNfts(userAddress: string): Promise<number[]>;
+    getPortfolioSummary(userAddress: string, portfolioLendingPools: PortfolioLendingPool[]): Promise<PortfolioSummary>;
+    getPortfolioLendingData(userAddress: string, poolOverviews: PoolOverview[], currentEpoch: string, provider?: Provider): Promise<PortfolioLendingPool[]>;
+    precisionToString(val: number): string;
+    calculateFixedTermDepositEarnings(fixedTermDepositLock: UserLendingPoolTrancheFixedTermDepositLock, totalTrancheBalance: string, totalTrancheShares: string): number;
+}