impermax-sdk 1.2.112 → 2.1.0

package/lib/onchain/account/lendingPool/onchainAccountLendingPoolV2.js

@@ -0,0 +1,285 @@
+"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 onchainTypes_1 = require("../../onchainTypes");
+const factories_1 = require("../../../config/factories");
+const lliquidity_math_1 = require("../../../utils/lliquidity-math");
+const utils_1 = require("../../../utils");
+const onchainAccountLendingPool_1 = __importDefault(require("./onchainAccountLendingPool"));
+const onchainAccountBorrowableV2_1 = __importDefault(require("./onchainAccountBorrowableV2"));
+const onchainAccountCollateralV2_1 = __importDefault(require("./onchainAccountCollateralV2"));
+class OnchainAccountLendingPoolV2 extends onchainAccountLendingPool_1.default {
+    constructor() {
+        super(...arguments);
+        // Shortcuts
+        this.getLendingPool = () => this.lendingPool;
+        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 onchainAccountCollateralV2_1.default(this);
+    }
+    getNewBorrowableObject(borrowable) {
+        return new onchainAccountBorrowableV2_1.default(this, borrowable);
+    }
+    getInteractionsLendingPool() {
+        return this.account.getInteractions().getLendingPool(this.getFactory(), this.getId());
+    }
+    // LP equity number in LPs
+    getLPEquity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lpEquityUSD = yield this.getLPEquityUSD();
+            const tokenPrice = yield this.getCollateral().getTokenPriceAccurate();
+            const stakedLPExchangeRate = yield this.lendingPool.getStakedLPExchangeRate();
+            return lpEquityUSD / tokenPrice * stakedLPExchangeRate;
+        });
+    }
+    // Values
+    getValuesFromPrice(changes, priceA, priceB) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const valueCollateral = (yield this.getCollateral().getDeposited()) + changes.changeCollateral;
+            const amountA = (yield this.getBorrowableA().getBorrowed()) + changes.changeBorrowedA;
+            const amountB = (yield this.getBorrowableB().getBorrowed()) + changes.changeBorrowedB;
+            const valueA = amountA * priceA;
+            const valueB = amountB * priceB;
+            return {
+                valueCollateral: valueCollateral > 0 ? valueCollateral : 0,
+                valueA: valueA > 0 ? valueA : 0,
+                valueB: valueB > 0 ? valueB : 0,
+            };
+        });
+    }
+    getValues(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [priceA, priceB] = yield this.lendingPool.getPriceDenomLP();
+            return this.getValuesFromPrice(changes, priceA, priceB);
+        });
+    }
+    getMarketValues(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [priceA, priceB] = yield this.lendingPool.getMarketPriceDenomLP();
+            return this.getValuesFromPrice(changes, priceA, priceB);
+        });
+    }
+    // Leverage
+    getLeverage(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!changes)
+                changes = onchainTypes_1.NO_CHANGES;
+            const { valueCollateral, valueA, valueB } = yield this.getValues(changes);
+            const valueDebt = valueA + valueB;
+            if (valueDebt == 0)
+                return 1;
+            const equity = valueCollateral - valueDebt;
+            if (equity <= 0)
+                return Infinity;
+            return valueDebt / equity + 1;
+        });
+    }
+    // Liquidation Threshold
+    /*public async getLiquidationPriceSwingsGivenValues(values: Values) : Promise<[number, number]> {
+      if (!values) return [Infinity, Infinity];
+      const { valueCollateral, valueA, valueB } = values;
+      if (valueA + valueB == 0) return [Infinity, Infinity];
+      const safetyMargin = await this.getSafetyMargin();
+      const liquidationPenalty = await this.getLiquidationPenalty();
+      const actualCollateral = valueCollateral / liquidationPenalty;
+      const rad = Math.sqrt(actualCollateral ** 2 - 4 * valueA * valueB);
+      if (!rad) return [0, 0];
+      const t = (actualCollateral + rad) / (2 * Math.sqrt(safetyMargin));
+      let priceSwingA = (t / valueA) ** 2;
+      let priceSwingB = (t / valueB) ** 2;
+      return [priceSwingA, priceSwingB];
+    }
+    public async getLiquidationPricesGivenValues(values: Values) : Promise<[number, number]> {
+      const currentPrice = await this.lendingPool.getTWAPPrice();
+      const [priceSwingA, priceSwingB] = await this.getLiquidationPriceSwingsGivenValues(values);
+      return !this.account.getOnchain().priceInverted ? [currentPrice / priceSwingB, currentPrice * priceSwingA] : [currentPrice / priceSwingA, currentPrice * priceSwingB];
+    }
+    public async getLiquidationPriceSwings(changes?: Changes) {
+      if (!changes) changes = NO_CHANGES;
+      const values = await this.getValues(changes);
+      return this.getLiquidationPriceSwingsGivenValues(values);
+    }
+    public async getLiquidationPrices(changes?: Changes) {
+      if (!changes) changes = NO_CHANGES;
+      const values = await this.getValues(changes);
+      return this.getLiquidationPricesGivenValues(values);
+    }*/
+    getLiquidationPrices(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!changes)
+                changes = onchainTypes_1.NO_CHANGES;
+            const collateralAmount = Math.max((yield this.getCollateral().getDeposited()) + changes.changeCollateral, 0);
+            const debtA = Math.max((yield this.getBorrowableA().getBorrowed()) + changes.changeBorrowedA, 0);
+            const debtB = Math.max((yield this.getBorrowableB().getBorrowed()) + changes.changeBorrowedB, 0);
+            const safetyMargin = yield this.getSafetyMargin();
+            const liquidationPenalty = yield this.getLiquidationPenalty();
+            const actualCollateral = collateralAmount / liquidationPenalty;
+            const [reservesWeight0, reservesWeight1] = yield this.lendingPool.getTwapReservesWeights();
+            const [priceA, priceB] = yield this.lendingPool.getPriceDenomLP();
+            const collateralA = actualCollateral * reservesWeight0 / priceA;
+            const collateralB = actualCollateral * reservesWeight1 / priceB;
+            let priceSwingA, priceSwingB;
+            if (factories_1.STABLE_FACTORIES.includes(this.lendingPool.getImpermaxFactory().getFactory())) {
+                priceSwingA = (0, lliquidity_math_1.solidlyStable_getLiquidatableXPriceDecrease)(collateralA, collateralB, debtA, debtB) * safetyMargin;
+                priceSwingB = (0, lliquidity_math_1.solidlyStable_getLiquidatableXPriceDecrease)(collateralB, collateralA, debtB, debtA) * safetyMargin;
+            }
+            else {
+                priceSwingA = (0, lliquidity_math_1.uniswapV2_getLiquidatableXPriceDecrease)(collateralA, collateralB, debtA, debtB) * safetyMargin;
+                priceSwingB = (0, lliquidity_math_1.uniswapV2_getLiquidatableXPriceDecrease)(collateralB, collateralA, debtB, debtA) * safetyMargin;
+            }
+            const twapPrice = yield this.lendingPool.getTWAPPrice();
+            return !this.account.getOnchain().priceInverted
+                ? [twapPrice * priceSwingA, twapPrice / priceSwingB]
+                : [twapPrice * priceSwingB, twapPrice / priceSwingA];
+        });
+    }
+    // Max Leverage
+    /*public async getMaxLeverage() : Promise<number> {
+      const availableCashA = await this.getBorrowableA().getPoolToken().getTotalBalance();
+      const availableCashB = await this.getBorrowableB().getPoolToken().getTotalBalance();
+      const [priceA, priceB] = await this.lendingPool.getMarketPriceDenomLP();
+      const [priceATWAP,] = await this.lendingPool.getPriceDenomLP();
+      const diff = priceA > priceATWAP ? priceA / priceATWAP : priceATWAP / priceA;
+      const adjustFactor = 1 / diff;
+      const availableCashValue1 = availableCashA * priceA;
+      const availableCashValue2 = availableCashB * priceB;
+      const { valueCollateral, valueA, valueB } = await this.getValues(NO_CHANGES);
+      const safetyMargin = (await this.getSafetyMargin()) * this.getUiMargin();
+      const liquidationPenalty = await this.getLiquidationPenalty();
+      const actualCollateral = valueCollateral / liquidationPenalty;
+      const num1 = actualCollateral * Math.sqrt(safetyMargin) - valueA * safetyMargin - valueB;
+      const num2 = actualCollateral * Math.sqrt(safetyMargin) - valueB * safetyMargin - valueA;
+      const den = safetyMargin + 1 - 2 * Math.sqrt(safetyMargin) / liquidationPenalty;
+      const additionalValueBorrowablePerSide = Math.min(num1 / den, num2 / den, availableCashValue1, availableCashValue2) * adjustFactor;
+      const valueDebt = valueA + valueB;
+      const equity = valueCollateral - valueDebt;
+      if (equity == 0) return 1;
+      return (valueDebt + additionalValueBorrowablePerSide * 2) / equity + 1;
+    }*/
+    // binary search how much additional leverage we can get
+    getMaxLeverage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableCashA = yield this.getBorrowableA().getPoolToken().getTotalBalance();
+            const availableCashB = yield this.getBorrowableB().getPoolToken().getTotalBalance();
+            const collateralAmount = yield this.getCollateral().getDeposited();
+            const [reservesWeight0, reservesWeight1] = yield this.lendingPool.getMarketReservesWeights();
+            //const [priceA, priceB] = await this.lendingPool.getPriceDenomLP();
+            //TODO come posso adattare l'aggiustamento alle stable pairs?
+            const [priceA, priceB] = yield this.lendingPool.getMarketPriceDenomLP();
+            const [priceATWAP,] = yield this.lendingPool.getPriceDenomLP();
+            const diff = priceA > priceATWAP ? priceA / priceATWAP : priceATWAP / priceA;
+            const collateralA = collateralAmount * reservesWeight0 / priceA;
+            const collateralB = collateralAmount * reservesWeight1 / priceB;
+            const twapPrice = yield this.lendingPool.getTWAPPrice();
+            // start search
+            let addLev = 100;
+            let addLevPrev = 0;
+            let bestChanges = onchainTypes_1.NO_CHANGES;
+            for (let i = 0; i < 1000; i++) {
+                const jump = Math.abs(addLev - addLevPrev) / 2;
+                if (jump < 0.01)
+                    break;
+                addLevPrev = addLev;
+                const adjustFactor = Math.pow((0, utils_1.impermanentLoss)(Math.pow(diff, 2)), addLev);
+                const actualAddLev = addLev * adjustFactor;
+                const changeCollateral = collateralAmount * actualAddLev;
+                const changeBorrowedA = collateralA * actualAddLev;
+                const changeBorrowedB = collateralB * actualAddLev;
+                if (changeBorrowedA > availableCashA || changeBorrowedB > availableCashB) {
+                    addLev -= jump;
+                    continue;
+                }
+                const changes = { changeCollateral, changeBorrowedA, changeBorrowedB };
+                const [liqPriceA, liqPriceB] = yield this.getLiquidationPrices(changes);
+                if (liqPriceA * this.getUiMargin() > twapPrice || liqPriceB / this.getUiMargin() < twapPrice)
+                    addLev -= jump;
+                else {
+                    bestChanges = changes;
+                    addLev += jump;
+                }
+            }
+            const maxLeverage = yield this.getLeverage(bestChanges);
+            return Math.floor(maxLeverage * 100) / 100;
+        });
+    }
+    // Max Deleverage
+    getMaxDeleverage(slippage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { valueCollateral, valueA, valueB } = yield this.getMarketValues(onchainTypes_1.NO_CHANGES);
+            const [reservesWeight0, reservesWeight1] = yield this.lendingPool.getMarketReservesWeights();
+            const collateralValueA = valueCollateral * reservesWeight0;
+            const collateralValueB = valueCollateral * reservesWeight1;
+            if (collateralValueA >= valueA && collateralValueB >= valueB) {
+                return (yield this.getCollateral().getDeposited()) * this.account.getOnchain().dust;
+            }
+            if (valueCollateral < valueA + valueB) {
+                return 0;
+            }
+            if (valueA / collateralValueA < valueB / collateralValueB) {
+                return (valueA + valueA / collateralValueA * collateralValueB);
+            }
+            else {
+                return (valueB + valueB / collateralValueB * collateralValueA);
+            }
+        });
+    }
+    // Available Reward
+    getAvailableReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = [];
+            const farmingAmount = (yield this.getBorrowableA().getAvailableFarmingReward()) + (yield this.getBorrowableB().getAvailableFarmingReward());
+            if (farmingAmount > 0) {
+                const farmingSymbol = yield this.getBorrowableA().getPoolToken().getFarmingTokenSymbol();
+                result.push({
+                    symbol: farmingSymbol,
+                    amount: farmingAmount
+                });
+            }
+            const rewarderSymbols = [
+                yield this.getBorrowableA().getPoolToken().getRewarderTokenSymbol(),
+                yield this.getBorrowableB().getPoolToken().getRewarderTokenSymbol()
+            ];
+            const rewarderAmounts = [
+                yield this.getBorrowableA().getAvailableRewarderReward(),
+                yield this.getBorrowableB().getAvailableRewarderReward()
+            ];
+            if (rewarderSymbols[0] === rewarderSymbols[1]) {
+                const rewarderAmount = rewarderAmounts[0] + rewarderAmounts[1];
+                if (rewarderAmount === 0)
+                    return result;
+                result.push({
+                    symbol: rewarderSymbols[0],
+                    amount: rewarderAmount
+                });
+            }
+            else {
+                for (let i = 0; i < 2; i++) {
+                    if (rewarderAmounts[i] === 0)
+                        continue;
+                    result.push({
+                        symbol: rewarderSymbols[i],
+                        amount: rewarderAmounts[i]
+                    });
+                }
+            }
+            return result;
+        });
+    }
+}
+exports.default = OnchainAccountLendingPoolV2;

package/lib/onchain/account/lendingPool/onchainAccountLendingPoolV3.d.ts

@@ -0,0 +1,27 @@
+import { Borrowable } from '../../../config/types';
+import { OnchainLendingPoolV3 } from '../../impermaxFactory/lendingPool';
+import OnchainAccountLendingPool from "./onchainAccountLendingPool";
+import OnchainAccountCollateralV3 from "./onchainAccountCollateralV3";
+import OnchainAccountBorrowableV3 from "./onchainAccountBorrowableV3";
+import { OnchainInteractionsLendingPoolV3 } from "../../interactions/lendingPool";
+import OnchainAccountNftlp from "./nftlp";
+import OnchainAccount from "../index";
+export default class OnchainAccountLendingPoolV3 extends OnchainAccountLendingPool {
+    protected readonly lendingPool: OnchainLendingPoolV3;
+    protected readonly collateral: OnchainAccountCollateralV3;
+    protected readonly borrowables: {
+        [Borrowable.A]: OnchainAccountBorrowableV3;
+        [Borrowable.B]: OnchainAccountBorrowableV3;
+    };
+    protected readonly nftlp: OnchainAccountNftlp;
+    constructor(account: OnchainAccount, lendingPool: OnchainLendingPoolV3);
+    protected getNewCollateralObject(): OnchainAccountCollateralV3;
+    protected getNewBorrowableObject(borrowable: Borrowable): OnchainAccountBorrowableV3;
+    getLendingPool: () => OnchainLendingPoolV3;
+    getBorrowable: (borrowable: Borrowable) => OnchainAccountBorrowableV3;
+    getBorrowableA: () => OnchainAccountBorrowableV3;
+    getBorrowableB: () => OnchainAccountBorrowableV3;
+    getCollateral: () => OnchainAccountCollateralV3;
+    getNftlp: () => OnchainAccountNftlp;
+    getInteractionsLendingPool(): OnchainInteractionsLendingPoolV3;
+}

package/lib/onchain/account/lendingPool/onchainAccountLendingPoolV3.js

@@ -0,0 +1,32 @@
+"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 onchainAccountLendingPool_1 = __importDefault(require("./onchainAccountLendingPool"));
+const onchainAccountCollateralV3_1 = __importDefault(require("./onchainAccountCollateralV3"));
+const onchainAccountBorrowableV3_1 = __importDefault(require("./onchainAccountBorrowableV3"));
+class OnchainAccountLendingPoolV3 extends onchainAccountLendingPool_1.default {
+    constructor(account, lendingPool) {
+        super(account, lendingPool);
+        // Shortcuts
+        this.getLendingPool = () => this.lendingPool;
+        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;
+        this.nftlp = lendingPool.getNftlp().getNewAccountNftlpObject(this);
+    }
+    getNewCollateralObject() {
+        return new onchainAccountCollateralV3_1.default(this);
+    }
+    getNewBorrowableObject(borrowable) {
+        return new onchainAccountBorrowableV3_1.default(this, borrowable);
+    }
+    getInteractionsLendingPool() {
+        return this.account.getInteractions().getLendingPool(this.getFactory(), this.getId());
+    }
+}
+exports.default = OnchainAccountLendingPoolV3;

package/lib/onchain/account/onchainAccount.js

@@ -12,7 +12,6 @@ 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 onchainAccountLendingVault_1 = __importDefault(require("./onchainAccountLendingVault"));
 const merkle_distributors_1 = require("../../config/endpoints/merkle-distributors");
 const ethers_1 = require("ethers");
@@ -43,7 +42,7 @@ class OnchainAccount {
     }
     initializeLendingPool(factory, pair) {
         const lendingPool = this.onchain.getImpermaxFactory(factory).getLendingPool(pair);
-        return new lendingPool_1.default(this, lendingPool);
+        return lendingPool.getNewAccountLendingPoolObject(this);
     }
     getLendingPool(factory, pair) {
         if (!this.lendingPools[factory])

package/lib/onchain/account/onchainAccountLendingVault.d.ts

@@ -1,7 +1,7 @@
 import OnchainAccountPoolToken from './onchainAccountPoolToken';
 import OnchainAccount from './onchainAccount';
 import OnchainLendingVault from '../onchainLendingVault';
-import OffchainAccountLendingVault from '../../offchain/account/offchainAccountLendingVault';
+import OffchainAccountVault from '../../offchain/account/vault/offchainAccountVault';
 import OnchainInteractionsLendingVault from '../interactions/onchainInteractionsLendingVault';
 export default class OnchainAccountLendingVault extends OnchainAccountPoolToken {
     private account;
@@ -12,8 +12,8 @@ export default class OnchainAccountLendingVault extends OnchainAccountPoolToken
     getAccount: () => OnchainAccount;
     getInteractionsPoolToken(): OnchainInteractionsLendingVault;
     getInteractionsLendingVault: () => OnchainInteractionsLendingVault;
-    getOffchainAccountPoolToken(): Promise<OffchainAccountLendingVault>;
-    getOffchainAccountLendingVault: () => Promise<OffchainAccountLendingVault>;
+    getOffchainAccountPoolToken(): Promise<OffchainAccountVault>;
+    getOffchainAccountLendingVault: () => Promise<OffchainAccountVault>;
     cleanCache(): void;
     getMaxWithdrawable(): Promise<number>;
 }

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

@@ -1,5 +1,7 @@
 import * as lendingPool from './lendingPool';
 import OnchainLendingPool from "./lendingPool";
 import OnchainImpermaxFactory from './onchainImpermaxFactory';
-export { lendingPool, OnchainLendingPool, };
+import OnchainImpermaxFactoryV2 from './onchainImpermaxFactoryV2';
+import OnchainImpermaxFactoryV3 from './onchainImpermaxFactoryV3';
+export { lendingPool, OnchainLendingPool, OnchainImpermaxFactoryV2, OnchainImpermaxFactoryV3, };
 export default OnchainImpermaxFactory;

package/lib/onchain/impermaxFactory/index.js

@@ -26,10 +26,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnchainLendingPool = exports.lendingPool = void 0;
+exports.OnchainImpermaxFactoryV3 = exports.OnchainImpermaxFactoryV2 = exports.OnchainLendingPool = exports.lendingPool = void 0;
 const lendingPool = __importStar(require("./lendingPool"));
 exports.lendingPool = lendingPool;
 const lendingPool_1 = __importDefault(require("./lendingPool"));
 exports.OnchainLendingPool = lendingPool_1.default;
 const onchainImpermaxFactory_1 = __importDefault(require("./onchainImpermaxFactory"));
+const onchainImpermaxFactoryV2_1 = __importDefault(require("./onchainImpermaxFactoryV2"));
+exports.OnchainImpermaxFactoryV2 = onchainImpermaxFactoryV2_1.default;
+const onchainImpermaxFactoryV3_1 = __importDefault(require("./onchainImpermaxFactoryV3"));
+exports.OnchainImpermaxFactoryV3 = onchainImpermaxFactoryV3_1.default;
 exports.default = onchainImpermaxFactory_1.default;

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

@@ -1,5 +1,12 @@
+import * as nftlp from './nftlp';
 import OnchainCollateral from "./onchainCollateral";
 import OnchainBorrowable from "./onchainBorrowable";
 import OnchainLendingPool from './onchainLendingPool';
-export { OnchainBorrowable, OnchainCollateral, };
+import OnchainLendingPoolV2 from "./onchainLendingPoolV2";
+import OnchainBorrowableV2 from "./onchainBorrowableV2";
+import OnchainCollateralV2 from "./onchainCollateralV2";
+import OnchainLendingPoolV3 from "./onchainLendingPoolV3";
+import OnchainBorrowableV3 from "./onchainBorrowableV3";
+import OnchainCollateralV3 from "./onchainCollateralV3";
+export { nftlp, OnchainBorrowable, OnchainCollateral, OnchainLendingPool, OnchainLendingPoolV2, OnchainBorrowableV2, OnchainCollateralV2, OnchainLendingPoolV3, OnchainBorrowableV3, OnchainCollateralV3, };
 export default OnchainLendingPool;

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

@@ -1,12 +1,50 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnchainCollateral = exports.OnchainBorrowable = void 0;
+exports.OnchainCollateralV3 = exports.OnchainBorrowableV3 = exports.OnchainLendingPoolV3 = exports.OnchainCollateralV2 = exports.OnchainBorrowableV2 = exports.OnchainLendingPoolV2 = exports.OnchainLendingPool = exports.OnchainCollateral = exports.OnchainBorrowable = exports.nftlp = void 0;
+const nftlp = __importStar(require("./nftlp"));
+exports.nftlp = nftlp;
 const onchainCollateral_1 = __importDefault(require("./onchainCollateral"));
 exports.OnchainCollateral = onchainCollateral_1.default;
 const onchainBorrowable_1 = __importDefault(require("./onchainBorrowable"));
 exports.OnchainBorrowable = onchainBorrowable_1.default;
 const onchainLendingPool_1 = __importDefault(require("./onchainLendingPool"));
+exports.OnchainLendingPool = onchainLendingPool_1.default;
+const onchainLendingPoolV2_1 = __importDefault(require("./onchainLendingPoolV2"));
+exports.OnchainLendingPoolV2 = onchainLendingPoolV2_1.default;
+const onchainBorrowableV2_1 = __importDefault(require("./onchainBorrowableV2"));
+exports.OnchainBorrowableV2 = onchainBorrowableV2_1.default;
+const onchainCollateralV2_1 = __importDefault(require("./onchainCollateralV2"));
+exports.OnchainCollateralV2 = onchainCollateralV2_1.default;
+const onchainLendingPoolV3_1 = __importDefault(require("./onchainLendingPoolV3"));
+exports.OnchainLendingPoolV3 = onchainLendingPoolV3_1.default;
+const onchainBorrowableV3_1 = __importDefault(require("./onchainBorrowableV3"));
+exports.OnchainBorrowableV3 = onchainBorrowableV3_1.default;
+const onchainCollateralV3_1 = __importDefault(require("./onchainCollateralV3"));
+exports.OnchainCollateralV3 = onchainCollateralV3_1.default;
 exports.default = onchainLendingPool_1.default;

package/lib/onchain/impermaxFactory/lendingPool/nftlp/index.d.ts

@@ -0,0 +1,4 @@
+import OnchainNftlp from './onchainNftlp';
+import OnchainNftlpUniswapV3 from './onchainNftlpUniswapV3';
+export { OnchainNftlp, OnchainNftlpUniswapV3, };
+export default OnchainNftlp;

package/lib/onchain/impermaxFactory/lendingPool/nftlp/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnchainNftlpUniswapV3 = exports.OnchainNftlp = void 0;
+const onchainNftlp_1 = __importDefault(require("./onchainNftlp"));
+exports.OnchainNftlp = onchainNftlp_1.default;
+const onchainNftlpUniswapV3_1 = __importDefault(require("./onchainNftlpUniswapV3"));
+exports.OnchainNftlpUniswapV3 = onchainNftlpUniswapV3_1.default;
+exports.default = onchainNftlp_1.default;

package/lib/onchain/impermaxFactory/lendingPool/nftlp/onchainNftlp.d.ts

@@ -0,0 +1,22 @@
+import OnchainLendingPoolV3 from "../onchainLendingPoolV3";
+import { Contract } from "../../../onchainTypes";
+import { OnchainAccountLendingPoolV3 } from "../../../account/lendingPool";
+import OnchainAccountNftlp from "../../../account/lendingPool/nftlp";
+import { OnchainInteractionsLendingPoolV3 } from "../../../interactions/lendingPool";
+import OnchainInteractionsNftlp from "../../../interactions/lendingPool/nftlp";
+export default abstract class OnchainNftlp {
+    protected readonly lendingPool: OnchainLendingPoolV3;
+    protected cache: {
+        nftlp?: Contract;
+    };
+    abstract getNewAccountNftlpObject(accountLendingPool: OnchainAccountLendingPoolV3): OnchainAccountNftlp;
+    abstract getNewInteractionsNftlpObject(accountLendingPool: OnchainInteractionsLendingPoolV3): OnchainInteractionsNftlp;
+    constructor(lendingPool: OnchainLendingPoolV3);
+    cleanCache(): void;
+    protected getContractHelper: () => import("../../..").OnchainContractsHelper;
+    getNftlpAddress: () => string;
+    protected abstract initializeNftlp(): Contract;
+    getNftlp(): any;
+    abstract getMarketPrice(): Promise<number>;
+    abstract getOraclePrice(): Promise<number>;
+}

package/lib/onchain/impermaxFactory/lendingPool/nftlp/onchainNftlp.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class OnchainNftlp {
+    constructor(lendingPool) {
+        this.cache = {};
+        this.getContractHelper = () => this.lendingPool.getImpermaxFactory().getOnchain().getContractHelper();
+        this.getNftlpAddress = () => this.lendingPool.getId();
+        this.lendingPool = lendingPool;
+    }
+    cleanCache() {
+        this.cache = {};
+    }
+    getNftlp() {
+        if (!this.cache.nftlp)
+            this.cache.nftlp = this.initializeNftlp();
+        return this.cache.nftlp;
+    }
+}
+exports.default = OnchainNftlp;

package/lib/onchain/impermaxFactory/lendingPool/nftlp/onchainNftlpUniswapV3.d.ts

@@ -0,0 +1,24 @@
+import OnchainNftlp from "./onchainNftlp";
+import { Contract } from "../../../onchainTypes";
+import { OnchainAccountLendingPoolV3 } from "../../../account/lendingPool";
+import { OnchainAccountNftlpUniswapV3 } from "../../../account/lendingPool/nftlp";
+import { OnchainInteractionsNftlpUniswapV3 } from "../../../interactions/lendingPool/nftlp";
+import { OnchainInteractionsLendingPoolV3 } from "../../../interactions/lendingPool";
+export default class OnchainNftlpUniswapV3 extends OnchainNftlp {
+    protected cache: {
+        nftlp?: Contract;
+        uniswapV3Pools?: {
+            [key in number]: Promise<Contract | null>;
+        };
+        marketPrice?: Promise<number>;
+        oraclePrice?: Promise<number>;
+    };
+    getNewAccountNftlpObject(accountNftlp: OnchainAccountLendingPoolV3): OnchainAccountNftlpUniswapV3;
+    getNewInteractionsNftlpObject(interactionsNftlp: OnchainInteractionsLendingPoolV3): OnchainInteractionsNftlpUniswapV3;
+    initializeNftlp(): any;
+    initializeUniswapV3Pool(fee: number): Promise<Contract | null>;
+    getUniswapV3Pool(fee: number): Promise<any>;
+    getMarketPrice(): Promise<number>;
+    private initializeOraclePrice;
+    getOraclePrice(): Promise<number>;
+}

package/lib/onchain/impermaxFactory/lendingPool/nftlp/onchainNftlpUniswapV3.js

@@ -0,0 +1,90 @@
+"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 onchainNftlp_1 = __importDefault(require("./onchainNftlp"));
+const nftlp_1 = require("../../../account/lendingPool/nftlp");
+const nftlp_2 = require("../../../interactions/lendingPool/nftlp");
+const FEES = [
+    100,
+    500,
+    3000,
+    10000,
+];
+class OnchainNftlpUniswapV3 extends onchainNftlp_1.default {
+    constructor() {
+        super(...arguments);
+        this.cache = {};
+    }
+    getNewAccountNftlpObject(accountNftlp) {
+        return new nftlp_1.OnchainAccountNftlpUniswapV3(accountNftlp);
+    }
+    getNewInteractionsNftlpObject(interactionsNftlp) {
+        return new nftlp_2.OnchainInteractionsNftlpUniswapV3(interactionsNftlp);
+    }
+    initializeNftlp() {
+        return this.getContractHelper().newNftlpUniV3(this.getNftlpAddress());
+    }
+    initializeUniswapV3Pool(fee) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nftlp = this.getNftlp();
+            try {
+                const poolAddress = yield nftlp.methods.getPool(fee).call();
+                return this.getContractHelper().newUniswapV3Pool(poolAddress);
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
+    getUniswapV3Pool(fee) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.uniswapV3Pools)
+                this.cache.uniswapV3Pools = {};
+            if (!this.cache.uniswapV3Pools[fee])
+                this.cache.uniswapV3Pools[fee] = this.initializeUniswapV3Pool(fee);
+            return this.cache.uniswapV3Pools[fee];
+        });
+    }
+    getMarketPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let priceCumulative = 0;
+            let liquidityCumulative = 0;
+            for (const fee of FEES) {
+                const pool = yield this.getUniswapV3Pool(fee);
+                if (!pool)
+                    continue;
+                const price = Math.pow(((yield pool.methods.slot0().call()).sqrtPriceX96 / Math.pow(2, 96)), 2);
+                const liquidity = (yield pool.methods.liquidity().call()) * 1;
+                priceCumulative += price * liquidity;
+                liquidityCumulative += liquidity;
+            }
+            return priceCumulative / liquidityCumulative;
+        });
+    }
+    ;
+    initializeOraclePrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nftlp = yield this.getNftlp();
+            return Math.pow((nftlp.methods.oraclePriceSqrtX96().call() / Math.pow(2, 96)), 2);
+        });
+    }
+    getOraclePrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.oraclePrice)
+                this.cache.oraclePrice = this.initializeOraclePrice();
+            return this.cache.oraclePrice;
+        });
+    }
+}
+exports.default = OnchainNftlpUniswapV3;