impermax-sdk 1.2.112 → 2.0.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/lendingVault.d.ts

@@ -0,0 +1,10 @@
+import Account from "./";
+import PoolToken from './poolToken';
+import * as onchain from '../index';
+export default class LendingVault extends PoolToken {
+    poolToken: onchain.LendingVault;
+    lendingVaultCache: {};
+    constructor(account: Account, lendingVault: onchain.LendingVault);
+    cleanCache(): void;
+    getMaxWithdrawable(): Promise<number>;
+}

package/lib/onchain/account/lendingVault.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const poolToken_1 = __importDefault(require("./poolToken"));
+class LendingVault extends poolToken_1.default {
+    constructor(account, lendingVault) {
+        super();
+        this.lendingVaultCache = {};
+        this.account = account;
+        this.poolToken = lendingVault;
+    }
+    cleanCache() {
+        this.cache = {};
+        this.lendingVaultCache = {};
+    }
+    // OnchainInteractions
+    getMaxWithdrawable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Math.min(yield this.getDeposited(), yield this.onchainPoolToken.getAvailableLiquidity()) / this.getDust();
+            // TODO remove dust?
+        });
+    }
+}
+exports.default = LendingVault;

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

@@ -1,32 +1,32 @@
-import OnChain from '../index';
-import { Address, Factory, FactoryIndex, LendingPoolIndex } from '../../config/types';
-import OnchainAccountLendingPool from './lendingPool';
-import OnchainAccountLendingVault from './onchainAccountLendingVault';
-import { AirdropData, PendingRewardUI } from '../onchainTypes';
-export default class OnchainAccount {
-    private readonly onchain;
-    private readonly accountAddress;
-    private readonly lendingPools;
-    private readonly lendingVaults;
-    private cache;
-    constructor(onchain: OnChain, account: Address);
-    getOnchain: () => OnChain;
-    getAccountAddress: () => string;
-    getInteractions: () => import("../index").OnchainInteractions;
-    getOffchainAccount: () => import("../..").OffchainAccount;
-    cleanCache(): Promise<void>;
-    private initializeLendingPool;
-    getLendingPool(factory: Factory, pair: Address): OnchainAccountLendingPool;
-    private initializeLendingVault;
-    getLendingVault(vaultAddress: Address): OnchainAccountLendingVault;
-    getMassAvailableReward(pairs: FactoryIndex<Address[]>): Promise<LendingPoolIndex<PendingRewardUI[]>>;
-    private initializeAirdropData;
-    private getAirdropData;
-    getIbexAirdropData(): Promise<AirdropData>;
-    getIbex2AirdropData(): Promise<AirdropData>;
-    getEthAirdropData(): Promise<AirdropData>;
-    hasIbexClaimableAirdrop(): Promise<boolean>;
-    hasEthClaimableAirdrop(): Promise<boolean>;
-    private initializeClaimableIBEX;
-    getClaimableIBEX(claimableAddress: Address): Promise<number>;
-}
+import OnChain from '../index';
+import { Address, Factory, FactoryIndex, LendingPoolIndex } from '../../config/types';
+import OnchainAccountLendingPool from './lendingPool';
+import OnchainAccountLendingVault from './onchainAccountLendingVault';
+import { AirdropData, PendingRewardUI } from '../onchainTypes';
+export default class OnchainAccount {
+    private readonly onchain;
+    private readonly accountAddress;
+    private readonly lendingPools;
+    private readonly lendingVaults;
+    private cache;
+    constructor(onchain: OnChain, account: Address);
+    getOnchain: () => OnChain;
+    getAccountAddress: () => string;
+    getInteractions: () => import("../index").OnchainInteractions;
+    getOffchainAccount: () => import("../..").OffchainAccount;
+    cleanCache(): Promise<void>;
+    private initializeLendingPool;
+    getLendingPool(factory: Factory, pair: Address): OnchainAccountLendingPool;
+    private initializeLendingVault;
+    getLendingVault(vaultAddress: Address): OnchainAccountLendingVault;
+    getMassAvailableReward(pairs: FactoryIndex<Address[]>): Promise<LendingPoolIndex<PendingRewardUI[]>>;
+    private initializeAirdropData;
+    private getAirdropData;
+    getIbexAirdropData(): Promise<AirdropData>;
+    getIbex2AirdropData(): Promise<AirdropData>;
+    getEthAirdropData(): Promise<AirdropData>;
+    hasIbexClaimableAirdrop(): Promise<boolean>;
+    hasEthClaimableAirdrop(): Promise<boolean>;
+    private initializeClaimableIBEX;
+    getClaimableIBEX(claimableAddress: Address): Promise<number>;
+}