impermax-sdk 1.2.112 → 2.0.0

package/lib/onchain/account/interactions/poolToken.js

@@ -0,0 +1,180 @@
+"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 });
+const ethers_1 = require("ethers");
+const types_1 = require("../../types");
+const types_2 = require("../../../config/types");
+const weths_1 = require("../../../config/contracts/weths");
+const general_1 = require("../../../config/general");
+const MAX_UINT256 = ethers_1.ethers.constants.MaxUint256;
+const EIP712DOMAIN = [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" },
+];
+const PERMIT = [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+];
+const TYPES = {
+    EIP712Domain: EIP712DOMAIN,
+    Permit: PERMIT,
+    BorrowPermit: PERMIT,
+};
+class PoolToken {
+    constructor() {
+        this.getOnchain = () => this.getInteractions().account.router;
+        this.getPoolToken = () => this.accountPoolToken.poolToken;
+    }
+    send(method, onTransactionHash, value) {
+        return this.getInteractions().send(method, onTransactionHash, value);
+    }
+    //send = this.getInteractions().send;
+    getOwnerSpender() {
+        return {
+            owner: this.getAccountAddress(),
+            spender: this.getRouterContract()._address,
+        };
+    }
+    isWETH() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.getPoolToken().getToken();
+            return token._address.toLowerCase() == weths_1.WETH[this.getOnchain().network].toLowerCase();
+        });
+    }
+    getAllowance(approvalType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolToken = yield this.getPoolToken().getPoolToken();
+            const token = yield this.getPoolToken().getToken();
+            if ((yield this.isWETH()) && approvalType == types_1.ApprovalType.UNDERLYING)
+                return MAX_UINT256;
+            const { owner, spender } = this.getOwnerSpender();
+            const allowance = (approvalType == types_1.ApprovalType.POOL_TOKEN) ? yield poolToken.methods.allowance(owner, spender).call() :
+                (approvalType == types_1.ApprovalType.UNDERLYING) ? yield token.methods.allowance(owner, spender).call() :
+                    (approvalType == types_1.ApprovalType.BORROW) ? yield poolToken.methods.borrowAllowance(owner, spender).call() : 0;
+            return ethers_1.BigNumber.from(allowance);
+        });
+    }
+    approve(approvalType, amount, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { spender } = this.getOwnerSpender();
+            const poolToken = yield this.getPoolToken().getPoolToken();
+            const token = yield this.getPoolToken().getToken();
+            let method;
+            if (approvalType == types_1.ApprovalType.POOL_TOKEN)
+                method = poolToken.methods.approve(spender, amount);
+            if (approvalType == types_1.ApprovalType.UNDERLYING)
+                method = token.methods.approve(spender, amount);
+            if (approvalType == types_1.ApprovalType.BORROW)
+                method = poolToken.methods.borrowApprove(spender, amount);
+            return this.send(method, onTransactionHash);
+        });
+    }
+    getPermitData(approvalType, amount, deadlineArg, callBack) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (approvalType === types_1.ApprovalType.UNDERLYING && this.getPoolToken().poolTokenType != types_2.PoolTokenType.Collateral)
+                return callBack(null);
+            const { owner, spender } = this.getOwnerSpender();
+            const poolToken = yield this.getPoolToken().getPoolToken();
+            const token = yield this.getPoolToken().getToken();
+            const contract = approvalType == types_1.ApprovalType.UNDERLYING ? token : poolToken;
+            const nonce = yield contract.methods.nonces(owner).call();
+            const name = yield contract.methods.name().call();
+            const deadline = deadlineArg ? deadlineArg : general_1.DEADLINE;
+            const data = JSON.stringify({
+                types: TYPES,
+                domain: {
+                    name: name,
+                    version: "1",
+                    chainId: this.getOnchain().chainId,
+                    verifyingContract: contract._address,
+                },
+                primaryType: approvalType == types_1.ApprovalType.BORROW ? "BorrowPermit" : "Permit",
+                message: {
+                    owner: owner,
+                    spender: spender,
+                    value: amount.toString(),
+                    nonce: ethers_1.BigNumber.from(nonce).toHexString(),
+                    deadline: deadline.toNumber(),
+                }
+            });
+            this.getOnchain().web3.currentProvider.send({
+                method: "eth_signTypedData_v4",
+                params: [owner, data],
+                from: owner
+            }, (err, data) => {
+                if (err) {
+                    console.error(err);
+                    return callBack(null);
+                }
+                const signature = data.result.substring(2);
+                const r = "0x" + signature.substring(0, 64);
+                const s = "0x" + signature.substring(64, 128);
+                let v = parseInt(signature.substring(128, 130), 16);
+                if (v == 0 || v == 1)
+                    v = v + 27;
+                //console.log(v, r, s);
+                const permitData = ethers_1.ethers.utils.defaultAbiCoder.encode(['bool', 'uint8', 'bytes32', 'bytes32'], [false, v, r, s]);
+                callBack({ permitData, deadline, amount });
+            });
+        });
+    }
+    getSendData(permitData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                router: this.getRouterContract(),
+                ptAddress: (yield this.getPoolToken().getPoolToken())._address,
+                account: this.accountPoolToken.getAccountAddress(),
+                data: permitData ? permitData.permitData : '0x',
+                deadline: permitData ? permitData.deadline : general_1.DEADLINE,
+            };
+        });
+    }
+    mintETH(amount, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { router, ptAddress, account, deadline } = yield this.getSendData(permitData);
+            return this.send(router.methods.mintETH(ptAddress, account, deadline), onTransactionHash, amount);
+        });
+    }
+    mint(amount, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { router, ptAddress, account, deadline } = yield this.getSendData(permitData);
+            return this.send(router.methods.mint(ptAddress, amount, account, deadline), onTransactionHash);
+        });
+    }
+    ;
+    deposit(amount, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.isWETH()) {
+                return this.mintETH(amount, permitData, onTransactionHash);
+            }
+            else {
+                return this.mint(amount, permitData, onTransactionHash);
+            }
+        });
+    }
+    withdraw(tokens, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { router, ptAddress, account, data, deadline } = yield this.getSendData(permitData);
+            if (yield this.isWETH()) {
+                return this.send(router.methods.redeemETH(ptAddress, tokens, account, deadline, data), onTransactionHash);
+            }
+            else {
+                return this.send(router.methods.redeem(ptAddress, tokens, account, deadline, data), onTransactionHash);
+            }
+        });
+    }
+}
+exports.default = PoolToken;

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

@@ -0,0 +1,29 @@
+import { PoolTokenType } from '../../../config/types';
+import LendingPool from './index';
+import * as onchain from '../../index';
+import PoolToken from '../poolToken';
+export default class Borrowable extends PoolToken {
+    accountLendingPool: LendingPool;
+    poolToken: onchain.impermaxFactory.lendingPool.Borrowable;
+    borrowableCache: {
+        borrowed?: Promise<number>;
+        farmingShares?: Promise<number>;
+        availableFarmingReward?: Promise<number>;
+        availableRewarderReward?: Promise<number>;
+    };
+    constructor(accountLendingPool: LendingPool, poolTokenType: PoolTokenType);
+    cleanCache(): void;
+    getSupplyAPR: () => Promise<number>;
+    getBorrowRate: () => Promise<number>;
+    getAccrualTimestamp: () => Promise<number>;
+    private initializeBorrowed;
+    getBorrowed(): Promise<number>;
+    getBorrowedUSD(): Promise<number>;
+    getMaxBorrowable(): Promise<number>;
+    private initializeFarmingShares;
+    getFarmingShares(): Promise<number>;
+    private initializeAvailableFarmingReward;
+    getAvailableFarmingReward(): Promise<number>;
+    private initializeAvailableRewarderReward;
+    getAvailableRewarderReward(): Promise<number>;
+}

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

@@ -0,0 +1,135 @@
+"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("../../types");
+const types_2 = require("../../../config/types");
+const poolToken_1 = __importDefault(require("../poolToken"));
+class Borrowable extends poolToken_1.default {
+    constructor(accountLendingPool, poolTokenType) {
+        super();
+        this.borrowableCache = {};
+        // Shortcuts
+        this.getSupplyAPR = () => __awaiter(this, void 0, void 0, function* () { return (yield this.onchainPoolToken.getOffchainPoolToken()).getSupplyAPR(); });
+        this.getBorrowRate = () => __awaiter(this, void 0, void 0, function* () { return (yield this.onchainPoolToken.getOffchainPoolToken()).getBorrowRate(); });
+        this.getAccrualTimestamp = () => __awaiter(this, void 0, void 0, function* () { return (yield this.onchainPoolToken.getOffchainPoolToken()).getAccrualTimestamp(); });
+        this.accountLendingPool = accountLendingPool;
+        this.account = accountLendingPool.account;
+        this.poolToken = accountLendingPool.lendingPool.poolTokens[poolTokenType];
+    }
+    cleanCache() {
+        super.cleanCache();
+        this.borrowableCache = {};
+    }
+    // Borrowed
+    initializeBorrowed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowable = yield this.onchainPoolToken.getPoolToken();
+            const balance = yield borrowable.methods.borrowBalance(this.getAccountAddress()).call();
+            const storedAmount = yield yield this.onchainPoolToken.normalize(balance);
+            const accrualTimestamp = yield this.getAccrualTimestamp();
+            const borrowRate = yield this.getBorrowRate();
+            return storedAmount * (1 + (Date.now() / 1000 - accrualTimestamp) * borrowRate);
+        });
+    }
+    getBorrowed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.borrowed)
+                this.borrowableCache.borrowed = this.initializeBorrowed();
+            return this.borrowableCache.borrowed;
+        });
+    }
+    getBorrowedUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowed = yield this.getBorrowed();
+            const tokenPrice = yield this.getTokenPriceAccurate();
+            return borrowed * tokenPrice;
+        });
+    }
+    // Max OffchainBorrowable
+    getMaxBorrowable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableCash = yield this.onchainPoolToken.getTotalBalance();
+            const { valueCollateral, valueA, valueB } = yield this.lendingPool.getValues(types_1.NO_CHANGES);
+            const [valueBorrowed, valueOther] = this.onchainPoolToken.poolTokenType == types_2.PoolTokenType.BorrowableA ? [valueA, valueB] : [valueB, valueA];
+            const safetyMargin = (yield this.lendingPool.getSafetyMargin()) * this.getUiMargin();
+            const liquidationPenalty = yield this.lendingPool.getLiquidationPenalty();
+            const actualCollateral = valueCollateral / liquidationPenalty;
+            const totalValueBorrowable1 = (actualCollateral * Math.sqrt(safetyMargin) - valueOther) / safetyMargin;
+            const totalValueBorrowable2 = (actualCollateral / Math.sqrt(safetyMargin) - valueOther) * safetyMargin;
+            const maxValueBorrowable = Math.min(totalValueBorrowable1, totalValueBorrowable2) - valueBorrowed;
+            const price = yield this.onchainPoolToken.getMarketPriceDenomLP();
+            return Math.max(0, Math.min(availableCash, maxValueBorrowable / price));
+        });
+    }
+    // Farming Shares
+    initializeFarmingShares() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.onchainPoolToken.hasImpermaxChef()))
+                return 0;
+            return (yield this.onchainPoolToken.getImpermaxChef().methods.userInfo(yield this.onchainPoolToken.getPoolTokenAddress(), this.getAccountAddress()).call()).shares;
+        });
+    }
+    getFarmingShares() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.farmingShares)
+                this.borrowableCache.farmingShares = this.initializeFarmingShares();
+            return this.borrowableCache.farmingShares;
+        });
+    }
+    // Available Reward
+    initializeAvailableFarmingReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.onchainPoolToken.hasImpermaxChef()))
+                return 0;
+            const borrowableAddress = yield this.onchainPoolToken.getPoolTokenAddress();
+            try {
+                return (yield this.onchainPoolToken.getImpermaxChef().methods.pendingReward(borrowableAddress, this.getAccountAddress()).call()) / 1e18;
+            }
+            catch (_a) {
+                console.log("Warning: pending reward negative");
+                return 0;
+            }
+        });
+    }
+    getAvailableFarmingReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.availableFarmingReward)
+                this.borrowableCache.availableFarmingReward = this.initializeAvailableFarmingReward();
+            return this.borrowableCache.availableFarmingReward;
+        });
+    }
+    initializeAvailableRewarderReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.onchainPoolToken.hasRewarder()))
+                return 0;
+            const borrowableAddress = yield this.onchainPoolToken.getPoolTokenAddress();
+            const rewarder = yield this.onchainPoolToken.getRewarder();
+            try {
+                return (yield rewarder.methods.pendingReward(borrowableAddress, this.getAccountAddress()).call()) / 1e18;
+            }
+            catch (_a) {
+                console.log("Warning: pending reward negative");
+                return 0;
+            }
+        });
+    }
+    getAvailableRewarderReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.availableRewarderReward)
+                this.borrowableCache.availableRewarderReward = this.initializeAvailableRewarderReward();
+            return this.borrowableCache.availableRewarderReward;
+        });
+    }
+}
+exports.default = Borrowable;

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

@@ -0,0 +1,15 @@
+import LendingPool from './index';
+import { PoolTokenType } from '../../../config/types';
+import * as onchain from '../../index';
+import PoolToken from '../poolToken';
+export default class Collateral extends PoolToken {
+    accountLendingPool: LendingPool;
+    poolToken: onchain.impermaxFactory.lendingPool.Collateral;
+    collateralCache: {};
+    constructor(accountLendingPool: LendingPool, poolTokenType: PoolTokenType);
+    cleanCache(): void;
+    fixStakedLPExchangeRate(n: Promise<number>): Promise<number>;
+    getAvailableBalanceUSD(): Promise<number>;
+    getDepositedUSD(): Promise<number>;
+    getMaxWithdrawable(): Promise<number>;
+}

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

@@ -0,0 +1,66 @@
+"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("../../types");
+const poolToken_1 = __importDefault(require("../poolToken"));
+class Collateral extends poolToken_1.default {
+    constructor(accountLendingPool, poolTokenType) {
+        super();
+        this.collateralCache = {};
+        this.accountLendingPool = accountLendingPool;
+        this.account = accountLendingPool.account;
+        this.poolToken = accountLendingPool.lendingPool.poolTokens[poolTokenType];
+    }
+    cleanCache() {
+        super.cleanCache();
+        this.collateralCache = {};
+    }
+    fixStakedLPExchangeRate(n) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stakedLPExchangeRate = yield this.onchainPoolToken.lendingPool.getStakedLPExchangeRate();
+            return (yield n) / stakedLPExchangeRate;
+        });
+    }
+    getAvailableBalanceUSD() {
+        const _super = Object.create(null, {
+            getAvailableBalanceUSD: { get: () => super.getAvailableBalanceUSD }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fixStakedLPExchangeRate(_super.getAvailableBalanceUSD.call(this));
+        });
+    }
+    getDepositedUSD() {
+        const _super = Object.create(null, {
+            getDepositedUSD: { get: () => super.getDepositedUSD }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fixStakedLPExchangeRate(_super.getDepositedUSD.call(this));
+        });
+    }
+    // Max Withdrawable
+    getMaxWithdrawable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deposited = yield this.getDeposited();
+            const availableCash = yield this.onchainPoolToken.getTotalBalance();
+            const { valueCollateral, valueA, valueB } = yield this.lendingPool.getValues(types_1.NO_CHANGES);
+            const safetyMargin = (yield this.lendingPool.getSafetyMargin()) * this.getUiMargin();
+            const liquidationPenalty = yield this.lendingPool.getLiquidationPenalty();
+            const actualCollateral = valueCollateral / liquidationPenalty;
+            const maxWithdrawable1 = (actualCollateral - (valueA + valueB * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty;
+            const maxWithdrawable2 = (actualCollateral - (valueB + valueA * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty;
+            return Math.max(0, Math.min(deposited, availableCash, maxWithdrawable1, maxWithdrawable2) / this.getDust());
+        });
+    }
+}
+exports.default = Collateral;

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

@@ -1,5 +1,12 @@
-import OnchainAccountBorrowable from "./onchainAccountBorrowable";
-import OnchainAccountCollateral from "./onchainAccountCollateral";
-import OnchainAccountLendingPool from './onchainAccountLendingPool';
-export { OnchainAccountBorrowable, OnchainAccountCollateral, };
-export default OnchainAccountLendingPool;
+import * as nftlp from './nftlp';
+import OnchainAccountBorrowable from "./onchainAccountBorrowable";
+import OnchainAccountBorrowableV2 from "./onchainAccountBorrowableV2";
+import OnchainAccountBorrowableV3 from "./onchainAccountBorrowableV3";
+import OnchainAccountCollateral from "./onchainAccountCollateral";
+import OnchainAccountCollateralV2 from "./onchainAccountCollateralV2";
+import OnchainAccountCollateralV3 from "./onchainAccountCollateralV3";
+import OnchainAccountLendingPool from './onchainAccountLendingPool';
+import OnchainAccountLendingPoolV2 from "./onchainAccountLendingPoolV2";
+import OnchainAccountLendingPoolV3 from "./onchainAccountLendingPoolV3";
+export { nftlp, OnchainAccountBorrowable, OnchainAccountCollateral, OnchainAccountLendingPoolV2, OnchainAccountBorrowableV2, OnchainAccountCollateralV2, OnchainAccountLendingPoolV3, OnchainAccountBorrowableV3, OnchainAccountCollateralV3, };
+export default OnchainAccountLendingPool;

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

@@ -1,12 +1,49 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnchainAccountCollateral = exports.OnchainAccountBorrowable = void 0;
-const onchainAccountBorrowable_1 = __importDefault(require("./onchainAccountBorrowable"));
-exports.OnchainAccountBorrowable = onchainAccountBorrowable_1.default;
-const onchainAccountCollateral_1 = __importDefault(require("./onchainAccountCollateral"));
-exports.OnchainAccountCollateral = onchainAccountCollateral_1.default;
-const onchainAccountLendingPool_1 = __importDefault(require("./onchainAccountLendingPool"));
-exports.default = onchainAccountLendingPool_1.default;
+"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.OnchainAccountCollateralV3 = exports.OnchainAccountBorrowableV3 = exports.OnchainAccountLendingPoolV3 = exports.OnchainAccountCollateralV2 = exports.OnchainAccountBorrowableV2 = exports.OnchainAccountLendingPoolV2 = exports.OnchainAccountCollateral = exports.OnchainAccountBorrowable = exports.nftlp = void 0;
+const nftlp = __importStar(require("./nftlp"));
+exports.nftlp = nftlp;
+const onchainAccountBorrowable_1 = __importDefault(require("./onchainAccountBorrowable"));
+exports.OnchainAccountBorrowable = onchainAccountBorrowable_1.default;
+const onchainAccountBorrowableV2_1 = __importDefault(require("./onchainAccountBorrowableV2"));
+exports.OnchainAccountBorrowableV2 = onchainAccountBorrowableV2_1.default;
+const onchainAccountBorrowableV3_1 = __importDefault(require("./onchainAccountBorrowableV3"));
+exports.OnchainAccountBorrowableV3 = onchainAccountBorrowableV3_1.default;
+const onchainAccountCollateral_1 = __importDefault(require("./onchainAccountCollateral"));
+exports.OnchainAccountCollateral = onchainAccountCollateral_1.default;
+const onchainAccountCollateralV2_1 = __importDefault(require("./onchainAccountCollateralV2"));
+exports.OnchainAccountCollateralV2 = onchainAccountCollateralV2_1.default;
+const onchainAccountCollateralV3_1 = __importDefault(require("./onchainAccountCollateralV3"));
+exports.OnchainAccountCollateralV3 = onchainAccountCollateralV3_1.default;
+const onchainAccountLendingPool_1 = __importDefault(require("./onchainAccountLendingPool"));
+const onchainAccountLendingPoolV2_1 = __importDefault(require("./onchainAccountLendingPoolV2"));
+exports.OnchainAccountLendingPoolV2 = onchainAccountLendingPoolV2_1.default;
+const onchainAccountLendingPoolV3_1 = __importDefault(require("./onchainAccountLendingPoolV3"));
+exports.OnchainAccountLendingPoolV3 = onchainAccountLendingPoolV3_1.default;
+exports.default = onchainAccountLendingPool_1.default;

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

@@ -0,0 +1,4 @@
+import OnchainAccountNftlp from './onchainAccountNftlp';
+import OnchainAccountNftlpUniswapV3 from './onchainAccountNftlpUniswapV3';
+export { OnchainAccountNftlp, OnchainAccountNftlpUniswapV3, };
+export default OnchainAccountNftlp;

package/lib/onchain/account/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.OnchainAccountNftlpUniswapV3 = exports.OnchainAccountNftlp = void 0;
+const onchainAccountNftlp_1 = __importDefault(require("./onchainAccountNftlp"));
+exports.OnchainAccountNftlp = onchainAccountNftlp_1.default;
+const onchainAccountNftlpUniswapV3_1 = __importDefault(require("./onchainAccountNftlpUniswapV3"));
+exports.OnchainAccountNftlpUniswapV3 = onchainAccountNftlpUniswapV3_1.default;
+exports.default = onchainAccountNftlp_1.default;

package/lib/onchain/account/lendingPool/nftlp/onchainAccountNftlp.d.ts

@@ -0,0 +1,7 @@
+import OnchainAccountLendingPoolV3 from "../onchainAccountLendingPoolV3";
+export default abstract class OnchainAccountNftlp {
+    protected readonly lendingPool: OnchainAccountLendingPoolV3;
+    protected cache: {};
+    constructor(lendingPool: OnchainAccountLendingPoolV3);
+    cleanCache(): void;
+}

package/lib/onchain/account/lendingPool/nftlp/onchainAccountNftlp.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class OnchainAccountNftlp {
+    constructor(lendingPool) {
+        this.cache = {};
+        this.lendingPool = lendingPool;
+    }
+    cleanCache() {
+        this.cache = {};
+    }
+}
+exports.default = OnchainAccountNftlp;

package/lib/onchain/account/lendingPool/nftlp/onchainAccountNftlpUniswapV3.d.ts

@@ -0,0 +1,4 @@
+import OnchainAccountNftlp from "./onchainAccountNftlp";
+export default class OnchainAccountNftlpUniswapV3 extends OnchainAccountNftlp {
+    protected cache: {};
+}

package/lib/onchain/account/lendingPool/nftlp/onchainAccountNftlpUniswapV3.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const onchainAccountNftlp_1 = __importDefault(require("./onchainAccountNftlp"));
+class OnchainAccountNftlpUniswapV3 extends onchainAccountNftlp_1.default {
+    constructor() {
+        super(...arguments);
+        this.cache = {};
+    }
+}
+exports.default = OnchainAccountNftlpUniswapV3;

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

@@ -1,34 +1,39 @@
-import { PoolTokenType } from '../../../config/types';
-import OnchainAccountLendingPool from './index';
-import OnchainAccountPoolToken from '../onchainAccountPoolToken';
-import OnchainBorrowable from '../../impermaxFactory/lendingPool/onchainBorrowable';
-import OnchainInteractionsBorrowable from '../../interactions/lendingPool/onchainInteractionsBorrowable';
-import OffchainAccountBorrowable from '../../../offchain/account/lendingPool/offchainAccountBorrowable';
-export default class OnchainAccountBorrowable extends OnchainAccountPoolToken {
-    private readonly lendingPool;
-    protected readonly poolToken: OnchainBorrowable;
-    private borrowableCache;
-    constructor(lendingPool: OnchainAccountLendingPool, poolTokenType: PoolTokenType);
-    getLendingPool: () => OnchainAccountLendingPool;
-    getPoolToken: () => OnchainBorrowable;
-    getAccount: () => import("..").default;
-    getInteractionsPoolToken(): OnchainInteractionsBorrowable;
-    getInteractionsBorrowable: () => OnchainInteractionsBorrowable;
-    getOffchainAccountPoolToken(): Promise<OffchainAccountBorrowable>;
-    getOffchainAccountBorrowable: () => Promise<OffchainAccountBorrowable>;
-    cleanCache(): void;
-    private getPoolTokenType;
-    getSupplyAPR: () => Promise<number>;
-    getBorrowRate: () => Promise<number>;
-    getAccrualTimestamp: () => Promise<number>;
-    private initializeBorrowed;
-    getBorrowed(): Promise<number>;
-    getBorrowedUSD(): Promise<number>;
-    getMaxBorrowable(): Promise<number>;
-    private initializeFarmingShares;
-    getFarmingShares(): Promise<number>;
-    private initializeAvailableFarmingReward;
-    getAvailableFarmingReward(): Promise<number>;
-    private initializeAvailableRewarderReward;
-    getAvailableRewarderReward(): Promise<number>;
-}
+import { Borrowable } from '../../../config/types';
+import OnchainAccountLendingPool from './index';
+import OnchainAccountPoolToken from '../onchainAccountPoolToken';
+import OnchainBorrowable from '../../impermaxFactory/lendingPool/onchainBorrowable';
+import OnchainInteractionsBorrowable from '../../interactions/lendingPool/onchainInteractionsBorrowable';
+import OffchainAccountBorrowable from '../../../offchain/account/lendingPool/offchainAccountBorrowable';
+export default abstract class OnchainAccountBorrowable extends OnchainAccountPoolToken {
+    protected readonly lendingPool: OnchainAccountLendingPool;
+    protected readonly poolToken: OnchainBorrowable;
+    protected borrowableCache: {
+        borrowed?: Promise<number>;
+        farmingShares?: Promise<number>;
+        availableFarmingReward?: Promise<number>;
+        availableRewarderReward?: Promise<number>;
+    };
+    constructor(lendingPool: OnchainAccountLendingPool, borrowable: Borrowable);
+    getLendingPool: () => OnchainAccountLendingPool;
+    getPoolToken: () => OnchainBorrowable;
+    getAccount: () => import("..").default;
+    getInteractionsPoolToken(): OnchainInteractionsBorrowable;
+    getInteractionsBorrowable: () => OnchainInteractionsBorrowable;
+    getOffchainAccountPoolToken(): Promise<OffchainAccountBorrowable>;
+    getOffchainAccountBorrowable: () => Promise<OffchainAccountBorrowable>;
+    cleanCache(): void;
+    protected getBorrowableType: () => Borrowable;
+    getSupplyAPR: () => Promise<number>;
+    getBorrowRate: () => Promise<number>;
+    getAccrualTimestamp: () => Promise<number>;
+    private initializeBorrowed;
+    getBorrowed(): Promise<number>;
+    getBorrowedUSD(): Promise<number>;
+    abstract getMaxBorrowable(): Promise<number>;
+    private initializeFarmingShares;
+    getFarmingShares(): Promise<number>;
+    private initializeAvailableFarmingReward;
+    getAvailableFarmingReward(): Promise<number>;
+    private initializeAvailableRewarderReward;
+    getAvailableRewarderReward(): Promise<number>;
+}