impermax-sdk 1.2.112 → 2.0.0

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

@@ -0,0 +1,338 @@
+"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 types_1 = require("../../../config/types");
+const factories_1 = require("../../../config/factories");
+const lliquidity_math_1 = require("../../../utils/lliquidity-math");
+const onchainLendingPool_1 = __importDefault(require("./onchainLendingPool"));
+const onchainCollateralV2_1 = __importDefault(require("./onchainCollateralV2"));
+const onchainBorrowableV2_1 = __importDefault(require("./onchainBorrowableV2"));
+const lendingPool_1 = require("../../account/lendingPool");
+const onchainInteractionsLendingPoolV2_1 = __importDefault(require("../../interactions/lendingPool/onchainInteractionsLendingPoolV2"));
+class OnchainLendingPoolV2 extends onchainLendingPool_1.default {
+    constructor() {
+        super(...arguments);
+        this.cache = {};
+        // Shortcuts
+        this.getBorrowable = (borrowable) => this.borrowables[borrowable];
+        this.getBorrowableA = () => this.getBorrowable(types_1.Borrowable.A);
+        this.getBorrowableB = () => this.getBorrowable(types_1.Borrowable.B);
+        this.getCollateral = () => this.collateral;
+    }
+    getNewCollateralObject() {
+        return new onchainCollateralV2_1.default(this);
+    }
+    getNewBorrowableObject(borrowable) {
+        return new onchainBorrowableV2_1.default(this, borrowable);
+    }
+    getNewAccountLendingPoolObject(account) {
+        return new lendingPool_1.OnchainAccountLendingPoolV2(account, this);
+    }
+    getNewInteractionLendingPoolObject(interactions) {
+        return new onchainInteractionsLendingPoolV2_1.default(interactions, this);
+    }
+    // Lending Pool V2 functions
+    initializeIsStakedLPToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.impermaxFactory.getRouter().methods.isStakedLPToken(this.id).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.id);
+        });
+    }
+    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.id);
+        });
+    }
+    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));
+                }
+                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.id).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() {
+        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;
+        });
+    }
+    getReinvestBountyFactor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.reinvestBountyFactor)
+                this.cache.reinvestBountyFactor = this.initializeReinvestBountyFactor();
+            return this.cache.reinvestBountyFactor;
+        });
+    }
+    // Reinvest Bounty
+    getReinvestBounty() {
+        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;
+        });
+    }
+}
+exports.default = OnchainLendingPoolV2;

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

@@ -0,0 +1,42 @@
+import { Address, Borrowable } from '../../../config/types';
+import { Contract } from '../../onchainTypes';
+import OnchainLendingPool from "./onchainLendingPool";
+import { OnchainAccountLendingPoolV3 } from "../../account/lendingPool";
+import OnchainAccount from "../../account";
+import OnchainInteractions from "../../interactions";
+import OnchainImpermaxFactoryV3 from "../onchainImpermaxFactoryV3";
+import OnchainCollateralV3 from './onchainCollateralV3';
+import OnchainBorrowableV3 from "./onchainBorrowableV3";
+import { OnchainInteractionsLendingPoolV3 } from "../../interactions/lendingPool";
+import OnchainImpermaxFactory from "../index";
+import OnchainNftlp from "./nftlp";
+export default class OnchainLendingPoolV3 extends OnchainLendingPool {
+    protected readonly impermaxFactory: OnchainImpermaxFactoryV3;
+    protected readonly collateral: OnchainCollateralV3;
+    protected readonly borrowables: {
+        [Borrowable.A]: OnchainBorrowableV3;
+        [Borrowable.B]: OnchainBorrowableV3;
+    };
+    protected readonly nftlp: OnchainNftlp;
+    protected cache: {
+        lendingPoolAddresses?: Promise<{
+            collateral: Address;
+            borrowables: {
+                [key in Borrowable]: Address;
+            };
+        }>;
+        uniswapV2Pair?: Promise<Contract>;
+        marketPrice?: Promise<number>;
+        TWAPPrice?: Promise<number>;
+    };
+    constructor(impermaxFactory: OnchainImpermaxFactory, id: Address);
+    protected getNewCollateralObject(): OnchainCollateralV3;
+    protected getNewBorrowableObject(borrowable: Borrowable): OnchainBorrowableV3;
+    getNewAccountLendingPoolObject(account: OnchainAccount): OnchainAccountLendingPoolV3;
+    getNewInteractionLendingPoolObject(interactions: OnchainInteractions): OnchainInteractionsLendingPoolV3;
+    getBorrowable: (borrowable: Borrowable) => OnchainBorrowableV3;
+    getBorrowableA: () => OnchainBorrowableV3;
+    getBorrowableB: () => OnchainBorrowableV3;
+    getCollateral: () => OnchainCollateralV3;
+    getNftlp: () => OnchainNftlp;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+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 onchainLendingPool_1 = __importDefault(require("./onchainLendingPool"));
+const lendingPool_1 = require("../../account/lendingPool");
+const onchainCollateralV3_1 = __importDefault(require("./onchainCollateralV3"));
+const onchainBorrowableV3_1 = __importDefault(require("./onchainBorrowableV3"));
+const lendingPool_2 = require("../../interactions/lendingPool");
+const nftlp_1 = require("./nftlp");
+class OnchainLendingPoolV3 extends onchainLendingPool_1.default {
+    constructor(impermaxFactory, id) {
+        super(impermaxFactory, id);
+        this.cache = {};
+        // Shortcuts
+        this.getBorrowable = (borrowable) => this.borrowables[borrowable];
+        this.getBorrowableA = () => this.getBorrowable(types_1.Borrowable.A);
+        this.getBorrowableB = () => this.getBorrowable(types_1.Borrowable.B);
+        this.getCollateral = () => this.collateral;
+        this.getNftlp = () => this.nftlp;
+        // TODO use the offchain object to get the type of nftlp
+        this.nftlp = new nftlp_1.OnchainNftlpUniswapV3(this);
+    }
+    getNewCollateralObject() {
+        return new onchainCollateralV3_1.default(this);
+    }
+    getNewBorrowableObject(borrowable) {
+        return new onchainBorrowableV3_1.default(this, borrowable);
+    }
+    getNewAccountLendingPoolObject(account) {
+        return new lendingPool_1.OnchainAccountLendingPoolV3(account, this);
+    }
+    getNewInteractionLendingPoolObject(interactions) {
+        return new lendingPool_2.OnchainInteractionsLendingPoolV3(interactions, this);
+    }
+}
+exports.default = OnchainLendingPoolV3;

package/lib/onchain/impermaxFactory/onchainImpermaxFactory.d.ts

@@ -1,16 +1,26 @@
-import OnChain from '../index';
-import { Address, Factory } from '../../config/types';
-import OnchainLendingPool from './lendingPool';
-export default class OnchainImpermaxFactory {
-    private readonly onchain;
-    private readonly factory;
-    private readonly lendingPools;
-    private cache;
-    constructor(router: OnChain, factory: Factory);
-    getOnchain: () => OnChain;
-    getFactory: () => Factory;
-    cleanCache(): void;
-    getSimpleUniswapOracle(): any;
-    getRouter(): any;
-    getLendingPool(uniswapV2PairAddress: Address): OnchainLendingPool;
-}
+import OnChain from '../index';
+import { Address, AddressIndex, Factory } from '../../config/types';
+import OnchainLendingPool from './lendingPool';
+import { Contract } from '../onchainTypes';
+export declare enum Version {
+    V2 = 0,
+    V3 = 1
+}
+export default abstract class OnchainImpermaxFactory {
+    readonly version: Version;
+    protected readonly onchain: OnChain;
+    protected readonly factory: Factory;
+    protected readonly lendingPools: AddressIndex<OnchainLendingPool>;
+    protected cache: {
+        poolTokenRouterContract?: Contract;
+        factoryContract?: Contract;
+    };
+    constructor(router: OnChain, factory: Factory);
+    getOnchain: () => OnChain;
+    getFactory: () => Factory;
+    cleanCache(): void;
+    protected abstract getNewLendingPoolObject(id: Address): OnchainLendingPool;
+    getLendingPool(id: Address): OnchainLendingPool;
+    getPoolTokenRouter(): any;
+    abstract getFactoryContract(): any;
+}

package/lib/onchain/impermaxFactory/onchainImpermaxFactory.js

@@ -1,52 +1,42 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const lendingPool_1 = __importDefault(require("./lendingPool"));
-const simple_uniswap_oracles_1 = require("../../config/contracts/simple-uniswap-oracles");
-const routers_1 = require("../../config/contracts/routers");
-class OnchainImpermaxFactory {
-    constructor(router, factory) {
-        this.cache = {};
-        this.getOnchain = () => this.onchain;
-        this.getFactory = () => this.factory;
-        this.onchain = router;
-        this.factory = factory;
-        this.lendingPools = {};
-    }
-    cleanCache() {
-        this.cache = {};
-        for (const pairAddress of Object.keys(this.lendingPools)) {
-            this.lendingPools[pairAddress].cleanCache();
-        }
-    }
-    getSimpleUniswapOracle() {
-        if (!this.cache.simpleUniswapOracleContract) {
-            const address = simple_uniswap_oracles_1.SIMPLE_UNISWAP_ORACLE[this.onchain.network][this.factory];
-            if (!address) {
-                console.error("SimpleUniswapOracle address not found");
-                return null;
-            }
-            this.cache.simpleUniswapOracleContract = this.onchain.getContractHelper().newSimpleUniswapOracle(address);
-        }
-        return this.cache.simpleUniswapOracleContract;
-    }
-    getRouter() {
-        if (!this.cache.routerContract) {
-            const address = routers_1.ROUTER[this.onchain.network][this.factory];
-            if (!address) {
-                console.error("Router address not found");
-                return null;
-            }
-            this.cache.routerContract = this.onchain.getContractHelper().newRouter(address);
-        }
-        return this.cache.routerContract;
-    }
-    getLendingPool(uniswapV2PairAddress) {
-        if (!this.lendingPools[uniswapV2PairAddress])
-            this.lendingPools[uniswapV2PairAddress] = new lendingPool_1.default(this, uniswapV2PairAddress);
-        return this.lendingPools[uniswapV2PairAddress];
-    }
-}
-exports.default = OnchainImpermaxFactory;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = void 0;
+const routers_1 = require("../../config/contracts/routers");
+var Version;
+(function (Version) {
+    Version[Version["V2"] = 0] = "V2";
+    Version[Version["V3"] = 1] = "V3";
+})(Version = exports.Version || (exports.Version = {}));
+class OnchainImpermaxFactory {
+    constructor(router, factory) {
+        this.cache = {};
+        this.getOnchain = () => this.onchain;
+        this.getFactory = () => this.factory;
+        this.onchain = router;
+        this.factory = factory;
+        this.lendingPools = {};
+    }
+    cleanCache() {
+        this.cache = {};
+        for (const pairAddress of Object.keys(this.lendingPools)) {
+            this.lendingPools[pairAddress].cleanCache();
+        }
+    }
+    getLendingPool(id) {
+        if (!this.lendingPools[id])
+            this.lendingPools[id] = this.getNewLendingPoolObject(id);
+        return this.lendingPools[id];
+    }
+    getPoolTokenRouter() {
+        if (!this.cache.poolTokenRouterContract) {
+            const address = routers_1.POOL_TOKEN_ROUTER[this.onchain.network];
+            if (!address) {
+                console.error("Pool token router address not found");
+                return null;
+            }
+            this.cache.poolTokenRouterContract = this.onchain.getContractHelper().newPoolTokenRouter(address);
+        }
+        return this.cache.poolTokenRouterContract;
+    }
+}
+exports.default = OnchainImpermaxFactory;

package/lib/onchain/impermaxFactory/onchainImpermaxFactoryV2.d.ts

@@ -0,0 +1,16 @@
+import { Address } from '../../config/types';
+import { Contract } from '../onchainTypes';
+import OnchainImpermaxFactory, { Version } from "./onchainImpermaxFactory";
+export default class OnchainImpermaxFactoryV2 extends OnchainImpermaxFactory {
+    readonly version = Version.V2;
+    protected cache: {
+        simpleUniswapOracleContract?: Contract;
+        poolTokenRouterContract?: Contract;
+        factoryContract?: Contract;
+        routerContract?: Contract;
+    };
+    protected getNewLendingPoolObject(id: Address): any;
+    getRouter(): any;
+    getFactoryContract(): Promise<any>;
+    getSimpleUniswapOracle(): any;
+}

package/lib/onchain/impermaxFactory/onchainImpermaxFactoryV2.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 });
+const lendingPool_1 = require("./lendingPool");
+const simple_uniswap_oracles_1 = require("../../config/contracts/simple-uniswap-oracles");
+const onchainImpermaxFactory_1 = __importStar(require("./onchainImpermaxFactory"));
+const routers_1 = require("../../config/contracts/routers");
+class OnchainImpermaxFactoryV2 extends onchainImpermaxFactory_1.default {
+    constructor() {
+        super(...arguments);
+        this.version = onchainImpermaxFactory_1.Version.V2;
+        this.cache = {};
+    }
+    getNewLendingPoolObject(id) {
+        return new lendingPool_1.OnchainLendingPoolV2(this, id);
+    }
+    getRouter() {
+        if (!this.cache.routerContract) {
+            const address = routers_1.ROUTER[this.onchain.network][this.factory];
+            if (!address) {
+                console.error("Router address not found");
+                return null;
+            }
+            this.cache.routerContract = this.onchain.getContractHelper().newRouterV2(address);
+        }
+        return this.cache.routerContract;
+    }
+    getFactoryContract() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.factoryContract) {
+                const router = this.getRouter();
+                const factoryAddress = router.methods.factory().call();
+                this.cache.factoryContract = this.onchain.getContractHelper().newFactoryV2(factoryAddress);
+            }
+            return this.cache.factoryContract;
+        });
+    }
+    getSimpleUniswapOracle() {
+        if (!this.cache.simpleUniswapOracleContract) {
+            const address = simple_uniswap_oracles_1.SIMPLE_UNISWAP_ORACLE[this.onchain.network][this.factory];
+            if (!address) {
+                console.error("SimpleUniswapOracle address not found");
+                return null;
+            }
+            this.cache.simpleUniswapOracleContract = this.onchain.getContractHelper().newSimpleUniswapOracle(address);
+        }
+        return this.cache.simpleUniswapOracleContract;
+    }
+}
+exports.default = OnchainImpermaxFactoryV2;