impermax-sdk 1.0.3 → 1.0.4

package/lib/subgraph/AccountPoolToken.js

@@ -0,0 +1,75 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class AccountPoolToken {
+    constructor(accountLendingPool, poolTokenType) {
+        this.accountLendingPool = accountLendingPool;
+        this.poolToken = accountLendingPool.lendingPool.poolTokens[poolTokenType];
+    }
+    getBorrowPosition() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userData = yield this.accountLendingPool.getUserData();
+            if (!userData)
+                return null;
+            const borrowPositions = userData.borrowPositions[this.poolToken.lendingPool.pairAddress];
+            if (!borrowPositions)
+                return null;
+            return borrowPositions[this.poolToken.poolTokenType];
+        });
+    }
+    getSupplyPosition() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userData = yield this.accountLendingPool.getUserData();
+            if (!userData)
+                return null;
+            const supplyPositions = userData.supplyPositions[this.poolToken.lendingPool.pairAddress];
+            if (!supplyPositions)
+                return null;
+            return supplyPositions[this.poolToken.poolTokenType];
+        });
+    }
+    getBorrowedAmount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowPosition = yield this.getBorrowPosition();
+            const borrowIndex = yield this.poolToken.getBorrowIndex();
+            if (!borrowPosition)
+                return 0;
+            const borrowBalance = parseFloat(borrowPosition.borrowBalance);
+            const userBorrowIndex = parseFloat(borrowPosition.borrowIndex);
+            return borrowBalance * borrowIndex / userBorrowIndex;
+        });
+    }
+    getBorrowedValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenPrice = yield this.poolToken.getTokenPriceAccurate();
+            const borrowedAmount = yield this.getBorrowedAmount();
+            return borrowedAmount * tokenPrice;
+        });
+    }
+    getSuppliedAmount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supplyPosition = yield this.getSupplyPosition();
+            if (!supplyPosition)
+                return 0;
+            const exchangeRate = yield this.poolToken.getExchangeRate();
+            const supplyBalance = parseFloat(supplyPosition.balance);
+            return supplyBalance * exchangeRate;
+        });
+    }
+    getSuppliedValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenPrice = yield this.poolToken.getTokenPriceAccurate();
+            const suppliedAmount = yield this.getSuppliedAmount();
+            return suppliedAmount * tokenPrice;
+        });
+    }
+}
+exports.default = AccountPoolToken;

package/lib/subgraph/LendingPool.d.ts

@@ -0,0 +1,38 @@
+import { LendingPoolData, LendingPoolPastData } from "../impermax-router/interfaces";
+import Subgraph from "./index";
+import PoolToken from "./PoolToken";
+import { Address, Amms, Factory, PoolTokenType } from '../config/types';
+import { Farms } from '../config/farms';
+export default class LendingPool {
+    subgraph: Subgraph;
+    factory: Factory;
+    pairAddress: Address;
+    poolTokens: {
+        [key in PoolTokenType]?: PoolToken;
+    };
+    constructor(subgraph: Subgraph, factory: Factory, pairAddress: Address);
+    getPoolToken(poolTokenType: PoolTokenType): PoolToken;
+    getLendingPoolData(): Promise<LendingPoolData>;
+    getSafetyMargin(): Promise<number>;
+    getLiquidationIncentive(): Promise<number>;
+    getLiquidationFee(): Promise<number>;
+    getLiquidationPenalty(): Promise<number>;
+    getUniswapAPR(): Promise<number>;
+    isStakedLPToken(): Promise<boolean>;
+    getStakedLPExchangeRate(): Promise<number>;
+    getStakingRewards(): Promise<Array<{
+        APR: number;
+        symbol: string;
+    }>>;
+    getStakingAPR(): Promise<number>;
+    getShownLeverage(): Promise<number>;
+    getLendingPoolDataPast24h(): Promise<LendingPoolPastData>;
+    getLendingPoolDataPast7d(): Promise<LendingPoolPastData>;
+    getAmm(): Promise<Amms>;
+    getFarm(): Promise<Farms>;
+    private calculateCollateralPrice;
+    getCollateralPrice(fast?: boolean): Promise<number>;
+    getUnderlyingLPPrice(fast?: boolean): Promise<number>;
+    getKinkMultiplier(): 2 | 5;
+    getTotalBorrowsUSD(): Promise<number>;
+}

package/lib/subgraph/LendingPool.js

@@ -0,0 +1,204 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PoolToken_1 = __importDefault(require("./PoolToken"));
+const utils_1 = require("../utils");
+const types_1 = require("../config/types");
+const amms_1 = require("../config/amms");
+const factories_1 = require("../config/factories");
+const farms_1 = require("../config/farms");
+class LendingPool {
+    constructor(subgraph, factory, pairAddress) {
+        this.subgraph = subgraph;
+        this.factory = factory;
+        this.pairAddress = pairAddress;
+        this.poolTokens = {};
+        this.poolTokens[types_1.PoolTokenType.Collateral] = new PoolToken_1.default(this, types_1.PoolTokenType.Collateral);
+        this.poolTokens[types_1.PoolTokenType.BorrowableA] = new PoolToken_1.default(this, types_1.PoolTokenType.BorrowableA);
+        this.poolTokens[types_1.PoolTokenType.BorrowableB] = new PoolToken_1.default(this, types_1.PoolTokenType.BorrowableB);
+    }
+    getPoolToken(poolTokenType) {
+        return this.poolTokens[poolTokenType];
+    }
+    // Subgraph calls
+    getLendingPoolData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.subgraph.getLendingPoolData(this.factory, this.pairAddress);
+        });
+    }
+    // Safety Margin
+    getSafetyMargin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.getLendingPoolData();
+            return parseFloat(lendingPoolData[types_1.PoolTokenType.Collateral].safetyMargin);
+        });
+    }
+    // Liquidation Penalty
+    getLiquidationIncentive() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.getLendingPoolData();
+            return parseFloat(lendingPoolData[types_1.PoolTokenType.Collateral].liquidationIncentive);
+        });
+    }
+    getLiquidationFee() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.getLendingPoolData();
+            const liquidationFee = lendingPoolData[types_1.PoolTokenType.Collateral].liquidationFee;
+            return liquidationFee ? parseFloat(liquidationFee) : 0;
+        });
+    }
+    getLiquidationPenalty() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getLiquidationIncentive()) + (yield this.getLiquidationFee());
+        });
+    }
+    // Uniswap APR
+    getUniswapAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.getLendingPoolData();
+            return lendingPoolData.pair.uniswapAPR;
+        });
+    }
+    // Staking
+    isStakedLPToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.getLendingPoolData();
+            return lendingPoolData.pair.isStakedLPToken;
+        });
+    }
+    getStakedLPExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.getLendingPoolData();
+            return parseFloat(lendingPoolData.pair.exchangeRate);
+        });
+    }
+    getStakingRewards() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const farm = yield this.getFarm();
+            const lendingPoolData = yield this.getLendingPoolData();
+            if (farm === farms_1.Farms.solidex || farm === farms_1.Farms.solidexB || farm === farms_1.Farms.solidexUSDC || farm === farms_1.Farms.solidexUSDCB) {
+                const solidexLPDetails = yield this.subgraph.solidexHelper.getSolidexLPDetails();
+                const result = solidexLPDetails[lendingPoolData.pair.uniswapV2PairAddress];
+                if (result)
+                    return result;
+            }
+            const FINISH_DELAY = 3600 * 24 * 1;
+            const rewards = [];
+            const stakedTotalSupply = parseFloat(lendingPoolData.pair.stakedTotalSupply);
+            const underlyingLPPrice = yield this.getUnderlyingLPPrice(true);
+            for (const reward of lendingPoolData.pair.rewards) {
+                const multiplier = farm === farms_1.Farms.traderJoeV2 ? 0.5 : 1;
+                const periodFinish = parseInt(reward.periodFinish);
+                if ((new Date).getTime() / 1000 - FINISH_DELAY > periodFinish && periodFinish !== 0)
+                    continue;
+                let rewardRate = parseFloat(reward.rewardRate);
+                if (farm == farms_1.Farms.traderJoeV4)
+                    rewardRate = rewardRate * 0.45;
+                const rewardPrice = yield this.subgraph.priceHelper.getDebankTokenPrice(reward.rewardsToken.id);
+                rewards.push({
+                    APR: (0, utils_1.toAPR)((rewardPrice * rewardRate) / (stakedTotalSupply * underlyingLPPrice) * multiplier),
+                    symbol: reward.rewardsToken.symbol,
+                });
+            }
+            return rewards;
+        });
+    }
+    getStakingAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rewards = yield this.getStakingRewards();
+            let APR = 0;
+            for (const reward of rewards) {
+                APR += reward.APR;
+            }
+            return APR;
+        });
+    }
+    //Shown Leverage
+    getShownLeverage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const safetyMargin = yield this.getSafetyMargin();
+            if (safetyMargin < 1.25)
+                return 20;
+            if (safetyMargin < 1.51)
+                return 10;
+            if (safetyMargin < 2.01)
+                return 5;
+            return 3;
+        });
+    }
+    // Past Data
+    getLendingPoolDataPast24h() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getLendingPoolData()).past24h;
+        });
+    }
+    getLendingPoolDataPast7d() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getLendingPoolData()).past7d;
+        });
+    }
+    // Amms and farms
+    getAmm() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.getLendingPoolData();
+            return (0, amms_1.getAmmByFactory)(this.subgraph.network, lendingPoolData.pair.uniswapV2Factory);
+        });
+    }
+    getFarm() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.getLendingPoolData();
+            return (0, farms_1.getFarmByStakedLPFactory)(this.subgraph.network, lendingPoolData.pair.factory);
+        });
+    }
+    // getCollateralPrice -> returns the price of the collateral, not necessarily of the underlying LP
+    calculateCollateralPrice(reserve0, reserve1, totalSupply, price0, price1) {
+        if (totalSupply === 0)
+            return 0;
+        const reserve0USD = reserve0 * price0;
+        const reserve1USD = reserve1 * price1;
+        // adjust reserves taking the latest price passed as parameters
+        const adjustedReserveUSD = Math.sqrt(reserve0USD * reserve1USD) * 2;
+        return adjustedReserveUSD / totalSupply;
+    }
+    getCollateralPrice(fast = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.getLendingPoolData();
+            return this.calculateCollateralPrice(parseFloat(lendingPoolData.pair.reserve0), parseFloat(lendingPoolData.pair.reserve1), parseFloat(lendingPoolData.pair.totalSupply), fast ?
+                yield this.poolTokens[types_1.PoolTokenType.BorrowableA].getTokenPriceFast() :
+                yield this.poolTokens[types_1.PoolTokenType.BorrowableA].getTokenPriceAccurate(), fast ?
+                yield this.poolTokens[types_1.PoolTokenType.BorrowableB].getTokenPriceFast() :
+                yield this.poolTokens[types_1.PoolTokenType.BorrowableB].getTokenPriceAccurate());
+        });
+    }
+    getUnderlyingLPPrice(fast = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getCollateralPrice(fast)) / (yield this.getStakedLPExchangeRate());
+        });
+    }
+    // Kink Multiplier
+    getKinkMultiplier() {
+        if (factories_1.OLD_KINK_MULTIPLIER_FACTORIES.includes(this.factory))
+            return 5;
+        return 2;
+    }
+    // Stats
+    getTotalBorrowsUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBorrowsUSDA = yield this.poolTokens[types_1.PoolTokenType.BorrowableA].getTotalBorrowsUSD();
+            const totalBorrowsUSDB = yield this.poolTokens[types_1.PoolTokenType.BorrowableB].getTotalBorrowsUSD();
+            return totalBorrowsUSDA + totalBorrowsUSDB;
+        });
+    }
+}
+exports.default = LendingPool;

package/lib/subgraph/PoolToken.d.ts

@@ -0,0 +1,64 @@
+import { PoolTokenData, BorrowablePastData } from "../impermax-router/interfaces";
+import LendingPool from "./LendingPool";
+import { Address, PoolTokenType } from '../config/types';
+export default class PoolToken {
+    lendingPool: LendingPool;
+    poolTokenType: PoolTokenType;
+    constructor(lendingPool: LendingPool, poolTokenType: PoolTokenType);
+    getPoolTokenData(): Promise<PoolTokenData>;
+    private getPoolTokenParam;
+    private getPoolTokenParamFloat;
+    private getUnderlyingParam;
+    getName(): Promise<string>;
+    getSymbol(): Promise<string>;
+    getDecimals(): Promise<number>;
+    getExchangeRate(): Promise<number>;
+    getUnderlyingAddress(): Promise<Address>;
+    getTotalBalance(): Promise<number>;
+    getTotalBalanceUSD(): Promise<number>;
+    getReserveFactor(): Promise<number>;
+    getKinkBorrowRate(): Promise<number>;
+    getKinkUtilizationRate(): Promise<number>;
+    getBorrowIndex(): Promise<number>;
+    getAccrualTimestamp(): Promise<number>;
+    getTotalBorrows(): Promise<number>;
+    getCurrentTotalBorrows(): Promise<number>;
+    getTotalBorrowsUSD(): Promise<number>;
+    getBorrowRate(): Promise<number>;
+    getBorrowAPR(): Promise<number>;
+    getNextBorrowRate(borrowAmount: number): Promise<number>;
+    getNextBorrowAPR(borrowAmount: number): Promise<number>;
+    getSupply(): Promise<number>;
+    getCurrentSupply(): Promise<number>;
+    getSupplyUSD(): Promise<number>;
+    getUtilizationRate(): Promise<number>;
+    getSupplyRate(): Promise<number>;
+    getSupplyAPR(): Promise<number>;
+    getNextSupplyRate(supplyAmount: number): Promise<number>;
+    getNextSupplyAPR(supplyAmount: number): Promise<number>;
+    getFarmingRewardsRate(): Promise<Array<{
+        rewardToken: string;
+        rewardRate: number;
+    }>>;
+    getFarmingRewards(): Promise<Array<{
+        APR: number;
+        symbol: string;
+    }>>;
+    getNextFarmingRewards(borrowAmount: number): Promise<Array<{
+        APR: number;
+        symbol: string;
+    }>>;
+    getFarmingAPR(): Promise<number>;
+    getNextFarmingAPR(borrowAmount: number): Promise<number>;
+    getPoolTokenDataPast24h(): Promise<BorrowablePastData>;
+    getPoolTokenDataPast7d(): Promise<BorrowablePastData>;
+    private getAverageBorrowAPR;
+    getAverage24hBorrowAPR(): Promise<number>;
+    getAverage7dBorrowAPR(): Promise<number>;
+    private getAverageSupplyAPR;
+    getAverage24hSupplyAPR(): Promise<number>;
+    getAverage7dSupplyAPR(): Promise<number>;
+    calculateCollateralPrice(reserve0: number, reserve1: number, totalSupply: number, price0: number, price1: number): number;
+    getTokenPriceFast(fallback?: boolean): Promise<number>;
+    getTokenPriceAccurate(): Promise<number>;
+}