impermax-sdk 1.2.112 → 2.1.0

package/lib/onchain/impermaxFactory/lendingPool/onchainLendingPool.js

@@ -8,36 +8,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 types_1 = require("../../../config/types");
-const onchainCollateral_1 = __importDefault(require("./onchainCollateral"));
-const onchainBorrowable_1 = __importDefault(require("./onchainBorrowable"));
-const factories_1 = require("../../../config/factories");
-const lliquidity_math_1 = require("../../../utils/lliquidity-math");
 class OnchainLendingPool {
-    constructor(impermaxFactory, pairAddress) {
+    constructor(impermaxFactory, id) {
         this.cache = {};
         this.getImpermaxFactory = () => this.impermaxFactory;
-        this.getPairAddress = () => this.pairAddress;
+        this.getId = () => this.id;
+        this.getBorrowable = (borrowable) => this.borrowables[borrowable];
         // Shortcuts
-        this.getBorrowableA = () => this.poolTokens[types_1.PoolTokenType.BorrowableA];
-        this.getBorrowableB = () => this.poolTokens[types_1.PoolTokenType.BorrowableB];
-        this.getCollateral = () => this.poolTokens[types_1.PoolTokenType.Collateral];
+        this.getBorrowableA = () => this.getBorrowable(types_1.Borrowable.A);
+        this.getBorrowableB = () => this.getBorrowable(types_1.Borrowable.B);
+        this.getCollateral = () => this.collateral;
         this.getContractHelper = () => this.impermaxFactory.getOnchain().getContractHelper();
         this.impermaxFactory = impermaxFactory;
-        this.pairAddress = pairAddress;
-        this.poolTokens = {
-            [types_1.PoolTokenType.Collateral]: new onchainCollateral_1.default(this),
-            [types_1.PoolTokenType.BorrowableA]: new onchainBorrowable_1.default(this, types_1.PoolTokenType.BorrowableA),
-            [types_1.PoolTokenType.BorrowableB]: new onchainBorrowable_1.default(this, types_1.PoolTokenType.BorrowableB),
+        this.id = id;
+        this.collateral = this.getNewCollateralObject();
+        this.borrowables = {
+            [types_1.Borrowable.A]: this.getNewBorrowableObject(types_1.Borrowable.A),
+            [types_1.Borrowable.B]: this.getNewBorrowableObject(types_1.Borrowable.B),
         };
     }
-    getPoolToken(poolTokenType) {
-        return this.poolTokens[poolTokenType];
-    }
     cleanCache() {
         this.cache = {};
         this.getBorrowableA().cleanCache();
@@ -46,317 +37,40 @@ class OnchainLendingPool {
     }
     getOffchainLendingPool() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.impermaxFactory.getOnchain().getOffchain().getLendingPool(this.impermaxFactory.getFactory(), this.pairAddress);
+            return this.impermaxFactory.getOnchain().getOffchain().getLendingPool(this.impermaxFactory.getFactory(), this.id);
         });
     }
-    initializePoolTokenAddresses() {
+    initializeLendingPoolAddresses() {
         return __awaiter(this, void 0, void 0, function* () {
-            const lPool = yield this.impermaxFactory.getRouter().methods.getLendingPool(this.pairAddress).call();
+            const lPool = yield (yield this.impermaxFactory.getFactoryContract()).methods.getLendingPool(this.id).call();
             return {
-                [types_1.PoolTokenType.Collateral]: lPool.collateral,
-                [types_1.PoolTokenType.BorrowableA]: lPool.borrowableA,
-                [types_1.PoolTokenType.BorrowableB]: lPool.borrowableB,
-            };
-        });
-    }
-    getPoolTokenAddresses() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.poolTokenAddresses)
-                this.cache.poolTokenAddresses = this.initializePoolTokenAddresses();
-            return this.cache.poolTokenAddresses;
-        });
-    }
-    initializeIsStakedLPToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.impermaxFactory.getRouter().methods.isStakedLPToken(this.pairAddress).call();
-            }
-            catch (e) {
-                return false;
-            }
-        });
-    }
-    getIsStakedLPToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.isStakedLPToken)
-                this.cache.isStakedLPToken = this.initializeIsStakedLPToken();
-            return this.cache.isStakedLPToken;
-        });
-    }
-    initializeStakedLPToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(yield this.getIsStakedLPToken()))
-                return null;
-            return this.getContractHelper().newStakedLPToken(this.pairAddress);
-        });
-    }
-    getStakedLPToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.stakedLPToken)
-                this.cache.stakedLPToken = this.initializeStakedLPToken();
-            return this.cache.stakedLPToken;
-        });
-    }
-    initializeUniswapV2Pair() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stakedLPToken = yield this.getStakedLPToken();
-            return this.getContractHelper().newUniswapV2Pair(stakedLPToken
-                ? yield (stakedLPToken.methods.underlying().call())
-                : this.pairAddress);
-        });
-    }
-    getUniswapV2Pair() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.uniswapV2Pair)
-                this.cache.uniswapV2Pair = this.initializeUniswapV2Pair();
-            return this.cache.uniswapV2Pair;
-        });
-    }
-    // Reserves
-    initializeReserves() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const uniswapV2Pair = yield this.getUniswapV2Pair();
-            const { reserve0, reserve1 } = yield uniswapV2Pair.methods.getReserves().call();
-            return [
-                yield this.getBorrowableA().normalize(reserve0),
-                yield this.getBorrowableB().normalize(reserve1),
-            ];
-        });
-    }
-    getReserves() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.reserves)
-                this.cache.reserves = this.initializeReserves();
-            return this.cache.reserves;
-        });
-    }
-    // LP Total Supply
-    initializeLPTotalSupply() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const uniswapV2Pair = yield this.getUniswapV2Pair();
-            const totalSupply = yield uniswapV2Pair.methods.totalSupply().call();
-            return this.getCollateral().normalize(totalSupply);
-        });
-    }
-    getLPTotalSupply() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.LPTotalSupply)
-                this.cache.LPTotalSupply = this.initializeLPTotalSupply();
-            return this.cache.LPTotalSupply;
-        });
-    }
-    // Price Denom LP
-    initializePriceDenomLP() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const collateral = yield this.getCollateral().getPoolToken();
-            const { price0, price1 } = yield collateral.methods.getPrices().call();
-            const decimalsA = yield this.getBorrowableA().getDecimals();
-            const decimalsB = yield this.getBorrowableB().getDecimals();
-            let stakedLPExchangeRate = yield this.getStakedLPExchangeRate();
-            return [
-                price0 / 1e18 / 1e18 * Math.pow(10, decimalsA) * stakedLPExchangeRate,
-                price1 / 1e18 / 1e18 * Math.pow(10, decimalsB) * stakedLPExchangeRate
-            ];
-        });
-    }
-    getPriceDenomLP() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.priceDenomLP)
-                this.cache.priceDenomLP = this.initializePriceDenomLP();
-            return this.cache.priceDenomLP;
-        });
-    }
-    getMarketPriceDenomLP() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [reserve0, reserve1] = yield this.getReserves();
-            const totalSupply = yield this.getLPTotalSupply();
-            const [reservesWeight0, reservesWeight1] = yield this.getMarketReservesWeights();
-            return [
-                totalSupply / reserve0 * reservesWeight0,
-                totalSupply / reserve1 * reservesWeight1,
-            ];
-        });
-    }
-    // Market Price
-    getMarketPrice() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [reserve0, reserve1] = yield this.getReserves();
-            const priceInverted = this.impermaxFactory.getOnchain().priceInverted;
-            if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory()))
-                return (0, lliquidity_math_1.solidlyStable_getPriceFromReserves)(reserve0, reserve1, priceInverted);
-            else
-                return (0, lliquidity_math_1.uniswapV2_getPriceFromReserves)(reserve0, reserve1, priceInverted);
-        });
-    }
-    // Value of reserveA / reserveB
-    initializeTwapReservesValueRatio() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
-                const collateral = yield this.getCollateral().getPoolToken();
-                let { twapReserve0, twapReserve1 } = yield collateral.methods.getTwapReserves().call();
-                const [price0, price1] = yield this.getPriceDenomLP();
-                twapReserve0 = yield this.getBorrowableA().normalize(twapReserve0);
-                twapReserve1 = yield this.getBorrowableB().normalize(twapReserve1);
-                return twapReserve0 * price0 / (twapReserve1 * price1);
-            }
-            else {
-                return 1;
-            }
-        });
-    }
-    getTwapReservesValueRatio() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.twapReservesValueRatio)
-                this.cache.twapReservesValueRatio = this.initializeTwapReservesValueRatio();
-            return this.cache.twapReservesValueRatio;
-        });
-    }
-    getTwapReservesWeights() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const reservesRatio = yield this.getTwapReservesValueRatio();
-            const reservesWeight0 = reservesRatio / (1 + reservesRatio);
-            const reservesWeight1 = 1 / (1 + reservesRatio);
-            return [reservesWeight0, reservesWeight1];
-        });
-    }
-    initializeMarketReservesValueRatio() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
-                const [reserve0, reserve1] = yield this.getReserves();
-                const price = (0, lliquidity_math_1.solidlyStable_getPriceFromReserves)(reserve0, reserve1);
-                return reserve0 * price / reserve1;
-            }
-            else {
-                return 1;
-            }
-        });
-    }
-    getMarketReservesValueRatio() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.marketReservesValueRatio)
-                this.cache.marketReservesValueRatio = this.initializeMarketReservesValueRatio();
-            return this.cache.marketReservesValueRatio;
-        });
-    }
-    getMarketReservesWeights() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const reservesRatio = yield this.getMarketReservesValueRatio();
-            const reservesWeight0 = reservesRatio / (1 + reservesRatio);
-            const reservesWeight1 = 1 / (1 + reservesRatio);
-            return [reservesWeight0, reservesWeight1];
-        });
-    }
-    // TWAP Price
-    initializeTWAPPrice() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const collateral = yield this.getCollateral().getPoolToken();
-                const decimalsA = yield this.getBorrowableA().getDecimals();
-                const decimalsB = yield this.getBorrowableB().getDecimals();
-                if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
-                    const { twapReserve0, twapReserve1 } = yield collateral.methods.getTwapReserves().call();
-                    return (0, lliquidity_math_1.solidlyStable_getPriceFromReserves)(twapReserve0 / Math.pow(10, decimalsA), twapReserve1 / Math.pow(10, decimalsB));
+                collateral: lPool.collateral,
+                borrowables: {
+                    [types_1.Borrowable.A]: lPool.borrowable0,
+                    [types_1.Borrowable.B]: lPool.borrowable1,
                 }
-                let price;
-                if (factories_1.SOLIDEX_FACTORIES.includes(this.impermaxFactory.getFactory())) {
-                    price = yield collateral.methods.getTwapPrice112x112().call();
-                }
-                else {
-                    price = (yield this.impermaxFactory.getSimpleUniswapOracle().methods.getResult(this.pairAddress).call()).price;
-                }
-                return price / Math.pow(2, 112) * Math.pow(10, decimalsA) / Math.pow(10, decimalsB);
-            }
-            catch (e) {
-                // Oracle is not initialized yet
-                return 0;
-            }
-        });
-    }
-    getTWAPPrice() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.TWAPPrice)
-                this.cache.TWAPPrice = this.initializeTWAPPrice();
-            return !this.impermaxFactory.getOnchain().priceInverted ? (yield this.cache.TWAPPrice) : 1 / (yield this.cache.TWAPPrice);
-        });
-    }
-    // Exchange rate
-    initializeStakedLPExchangeRate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stakedLPToken = yield this.getStakedLPToken();
-            if (!stakedLPToken)
-                return 1;
-            return (yield stakedLPToken.methods.exchangeRate().call()) / 1e18;
-        });
-    }
-    getStakedLPExchangeRate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.stakedLPExchangeRate)
-                this.cache.stakedLPExchangeRate = this.initializeStakedLPExchangeRate();
-            return this.cache.stakedLPExchangeRate;
-        });
-    }
-    // Pending Reward
-    initializePendingReward() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stakedLPToken = yield this.getStakedLPToken();
-            if (!stakedLPToken)
-                return null;
-            const rewardTokenAddress = yield stakedLPToken.methods.rewardsToken().call();
-            const rewardToken = this.getContractHelper().newERC20(rewardTokenAddress);
-            const decimals = yield rewardToken.methods.decimals().call();
-            let result = {
-                amount: 0,
-                symbol: yield rewardToken.methods.symbol().call(),
             };
-            try {
-                const pendingReward = yield stakedLPToken.methods.getReward().call();
-                result.amount = pendingReward / Math.pow(10, decimals);
-            }
-            catch (_a) {
-                try {
-                    const stakingRewardsAddress = yield stakedLPToken.methods.stakingRewards().call();
-                    const stakingRewards = this.getContractHelper().newStakingRewards(stakingRewardsAddress);
-                    const earned = yield stakingRewards.methods.earned(stakedLPToken._address).call();
-                    result.amount = earned / Math.pow(10, decimals);
-                }
-                catch (_b) { }
-            }
-            return result;
-        });
-    }
-    getPendingReward() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.pendingReward)
-                this.cache.pendingReward = this.initializePendingReward();
-            return this.cache.pendingReward;
         });
     }
-    // Reinvest Bounty Factor
-    initializeReinvestBountyFactor() {
+    getLendingPoolAddresses() {
         return __awaiter(this, void 0, void 0, function* () {
-            const stakedLPToken = yield this.getStakedLPToken();
-            if (!stakedLPToken)
-                return 0;
-            return (yield stakedLPToken.methods.REINVEST_BOUNTY().call()) / 1e18;
+            if (!this.cache.lendingPoolAddresses)
+                this.cache.lendingPoolAddresses = this.initializeLendingPoolAddresses();
+            return this.cache.lendingPoolAddresses;
         });
     }
-    getReinvestBountyFactor() {
+    getCollateralAddress() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.reinvestBountyFactor)
-                this.cache.reinvestBountyFactor = this.initializeReinvestBountyFactor();
-            return this.cache.reinvestBountyFactor;
+            return (yield this.getLendingPoolAddresses()).collateral;
         });
     }
-    // Reinvest Bounty
-    getReinvestBounty() {
+    ;
+    getBorrowableAddress(borrowable) {
         return __awaiter(this, void 0, void 0, function* () {
-            const pendingReward = yield this.getPendingReward();
-            if (!pendingReward)
-                return 0;
-            const reinvestBountyFactor = yield this.getReinvestBountyFactor();
-            return pendingReward.amount * reinvestBountyFactor;
+            return (yield this.getLendingPoolAddresses()).borrowables[borrowable];
         });
     }
+    ;
     // Has Farming
     hasFarming() {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/onchain/impermaxFactory/lendingPool/onchainLendingPoolV2.d.ts

@@ -0,0 +1,76 @@
+import { Address, Borrowable } from '../../../config/types';
+import { Contract, PendingRewardUI } from '../../onchainTypes';
+import OnchainLendingPool from "./onchainLendingPool";
+import OnchainCollateralV2 from "./onchainCollateralV2";
+import OnchainBorrowableV2 from "./onchainBorrowableV2";
+import OnchainImpermaxFactoryV2 from "../onchainImpermaxFactoryV2";
+import { OnchainAccountLendingPoolV2 } from "../../account/lendingPool";
+import OnchainAccount from "../../account";
+import OnchainInteractionsLendingPoolV2 from "../../interactions/lendingPool/onchainInteractionsLendingPoolV2";
+import OnchainInteractions from "../../interactions";
+export default class OnchainLendingPoolV2 extends OnchainLendingPool {
+    protected readonly impermaxFactory: OnchainImpermaxFactoryV2;
+    protected readonly collateral: OnchainCollateralV2;
+    protected readonly borrowables: {
+        [Borrowable.A]: OnchainBorrowableV2;
+        [Borrowable.B]: OnchainBorrowableV2;
+    };
+    protected cache: {
+        lendingPoolAddresses?: Promise<{
+            collateral: Address;
+            borrowables: {
+                [key in Borrowable]: Address;
+            };
+        }>;
+        isStakedLPToken?: Promise<boolean>;
+        uniswapV2Pair?: Promise<Contract>;
+        stakedLPToken?: Promise<Contract | null>;
+        reserves?: Promise<[number, number]>;
+        LPTotalSupply?: Promise<number>;
+        marketPrice?: Promise<number>;
+        priceDenomLP?: Promise<[number, number]>;
+        twapReservesValueRatio?: Promise<number>;
+        marketReservesValueRatio?: Promise<number>;
+        TWAPPrice?: Promise<number>;
+        pendingReward?: Promise<PendingRewardUI | null>;
+        reinvestBountyFactor?: Promise<number>;
+        stakedLPExchangeRate?: Promise<number>;
+    };
+    protected getNewCollateralObject(): OnchainCollateralV2;
+    protected getNewBorrowableObject(borrowable: Borrowable): OnchainBorrowableV2;
+    getNewAccountLendingPoolObject(account: OnchainAccount): OnchainAccountLendingPoolV2;
+    getNewInteractionLendingPoolObject(interactions: OnchainInteractions): OnchainInteractionsLendingPoolV2;
+    getBorrowable: (borrowable: Borrowable) => OnchainBorrowableV2;
+    getBorrowableA: () => OnchainBorrowableV2;
+    getBorrowableB: () => OnchainBorrowableV2;
+    getCollateral: () => OnchainCollateralV2;
+    private initializeIsStakedLPToken;
+    getIsStakedLPToken(): Promise<boolean>;
+    private initializeStakedLPToken;
+    getStakedLPToken(): Promise<any>;
+    private initializeUniswapV2Pair;
+    getUniswapV2Pair(): Promise<any>;
+    private initializeReserves;
+    getReserves(): Promise<[number, number]>;
+    private initializeLPTotalSupply;
+    getLPTotalSupply(): Promise<number>;
+    private initializePriceDenomLP;
+    getPriceDenomLP(): Promise<[number, number]>;
+    getMarketPriceDenomLP(): Promise<[number, number]>;
+    getMarketPrice(): Promise<number>;
+    private initializeTwapReservesValueRatio;
+    getTwapReservesValueRatio(): Promise<number>;
+    getTwapReservesWeights(): Promise<[number, number]>;
+    private initializeMarketReservesValueRatio;
+    getMarketReservesValueRatio(): Promise<number>;
+    getMarketReservesWeights(): Promise<[number, number]>;
+    private initializeTWAPPrice;
+    getTWAPPrice(): Promise<number>;
+    private initializeStakedLPExchangeRate;
+    getStakedLPExchangeRate(): Promise<number>;
+    private initializePendingReward;
+    getPendingReward(): Promise<PendingRewardUI | null>;
+    private initializeReinvestBountyFactor;
+    getReinvestBountyFactor(): Promise<number>;
+    getReinvestBounty(): Promise<number>;
+}