impermax-sdk 2.1.259 → 2.1.261

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

@@ -6,13 +6,7 @@ import OffchainBorrowable from '../../../offchain/lendingPool/offchainBorrowable
 export default abstract class OnchainBorrowable extends OnchainPoolToken {
     protected readonly lendingPool: OnchainLendingPool;
     protected readonly borrowable: Borrowable;
-    protected borrowableCache: {
-        borrowTracker?: Promise<Address>;
-        rewarder?: Promise<Contract>;
-        rewarderTokenSymbol?: Promise<string>;
-        farmingTokenSymbol?: Promise<string>;
-        rewardSpeed?: Promise<number>;
-    };
+    protected borrowableCache: {};
     constructor(lendingPool: OnchainLendingPool, borrowable: Borrowable);
     getLendingPool: () => OnchainLendingPool;
     getBorrowableType: () => Borrowable;
@@ -25,19 +19,4 @@ export default abstract class OnchainBorrowable extends OnchainPoolToken {
     protected initializeToken(): Promise<Contract>;
     isETH(): Promise<boolean>;
     getAvailableToBorrow(): Promise<number>;
-    /***
-     * TODO remove this part
-     **/
-    private initializeBorrowTracker;
-    getBorrowTracker(): Promise<string>;
-    hasFarming(): Promise<boolean>;
-    getImpermaxChef: () => any;
-    hasImpermaxChef(): Promise<boolean>;
-    private initializeFarmingTokenSymbol;
-    getFarmingTokenSymbol(): Promise<string>;
-    private initializeRewarder;
-    getRewarder(): Promise<any>;
-    hasRewarder(): Promise<boolean>;
-    private initializeRewarderTokenSymbol;
-    getRewarderTokenSymbol(): Promise<string>;
 }

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

@@ -13,8 +13,6 @@ class OnchainBorrowable extends onchainPoolToken_1.default {
         this.getBorrowableType = () => this.borrowable;
         this.getContractHelper = () => this.lendingPool.getImpermaxFactory().getOnchain().getContractHelper();
         this.getOffchainBorrowable = this.getOffchainPoolToken;
-        // Impermax Chef
-        this.getImpermaxChef = () => this.getContractHelper().impermaxChef;
         this.lendingPool = lendingPool;
         this.borrowable = borrowable;
     }
@@ -40,71 +38,5 @@ class OnchainBorrowable extends onchainPoolToken_1.default {
     async getAvailableToBorrow() {
         return await this.getTotalBalance();
     }
-    /***
-     * TODO remove this part
-     **/
-    // Farming Pool
-    async initializeBorrowTracker() {
-        const borrowable = await this.getPoolToken();
-        return borrowable.methods.borrowTracker().call();
-    }
-    async getBorrowTracker() {
-        if (!this.borrowableCache.borrowTracker)
-            this.borrowableCache.borrowTracker = this.initializeBorrowTracker();
-        return this.borrowableCache.borrowTracker;
-    }
-    async hasFarming() {
-        // remove old farming contracts, now it only has farming if it has the impermaxChef
-        return this.hasImpermaxChef();
-    }
-    async hasImpermaxChef() {
-        const borrowTracker = await this.getBorrowTracker();
-        return borrowTracker.toLowerCase() === (this.getImpermaxChef()._address ?? "").toLowerCase();
-    }
-    async initializeFarmingTokenSymbol() {
-        if (!await this.hasImpermaxChef())
-            return "";
-        const impermaxChef = await this.getImpermaxChef();
-        const farmingTokenAddress = await impermaxChef.methods.rewardToken().call();
-        return this.getContractHelper().newERC20(farmingTokenAddress).methods.symbol().call();
-    }
-    async getFarmingTokenSymbol() {
-        if (!this.borrowableCache.farmingTokenSymbol)
-            this.borrowableCache.farmingTokenSymbol = this.initializeFarmingTokenSymbol();
-        return this.borrowableCache.farmingTokenSymbol;
-    }
-    // Farming Pool Rewarder
-    async initializeRewarder() {
-        const poolTokenAddress = await this.getPoolTokenAddress();
-        try {
-            const { rewarder } = await this.getImpermaxChef().methods.poolInfo(poolTokenAddress).call();
-            if (rewarder == "0x0000000000000000000000000000000000000000")
-                return null;
-            return this.getContractHelper().newImpermaxChef(rewarder);
-        }
-        catch {
-            return null;
-        }
-    }
-    async getRewarder() {
-        if (!this.borrowableCache.rewarder)
-            this.borrowableCache.rewarder = this.initializeRewarder();
-        return this.borrowableCache.rewarder;
-    }
-    async hasRewarder() {
-        return await this.getRewarder() !== null;
-    }
-    async initializeRewarderTokenSymbol() {
-        if (!await this.hasRewarder())
-            return "";
-        const rewarder = await this.getRewarder();
-        const rewardTokenAddress = await rewarder.methods.rewardToken().call();
-        return this.getContractHelper().newERC20(rewardTokenAddress).methods.symbol().call();
-    }
-    async getRewarderTokenSymbol() {
-        if (!this.borrowableCache.rewarderTokenSymbol)
-            this.borrowableCache.rewarderTokenSymbol = this.initializeRewarderTokenSymbol();
-        return this.borrowableCache.rewarderTokenSymbol;
-    }
 }
 exports.default = OnchainBorrowable;

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

@@ -39,5 +39,4 @@ export default abstract class OnchainLendingPool {
     private getLendingPoolAddresses;
     getCollateralAddress(): Promise<string>;
     getBorrowableAddress(borrowable: Borrowable): Promise<string>;
-    hasFarming(): Promise<boolean>;
 }

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

@@ -52,9 +52,5 @@ class OnchainLendingPool {
         return (await this.getLendingPoolAddresses()).borrowables[borrowable];
     }
     ;
-    // Has Farming
-    async hasFarming() {
-        return await this.getBorrowableA().hasFarming() || await this.getBorrowableB().hasFarming();
-    }
 }
 exports.default = OnchainLendingPool;

package/lib/utils/borrowable/index.d.ts

@@ -0,0 +1,39 @@
+export interface BorrowableParams {
+    totalSupply: number;
+    totalBorrows: number;
+    kinkRate: number;
+    kinkUtilizationRate: number;
+    kinkMultiplier: number;
+    reserveFactor: number;
+}
+export declare class Borrowable {
+    totalSupply: number;
+    initialTotalSupply: number;
+    totalBorrows: number;
+    initialTotalBorrows: number;
+    kinkRate: number;
+    kinkUtilizationRate: number;
+    kinkMultiplier: number;
+    reserveFactor: number;
+    constructor(params: BorrowableParams);
+    /**
+     * PUBLIC GETTERS
+     */
+    getInitialUtilizationRate(): number;
+    getUtilizationRate(): number;
+    getInitialAvailableToBorrow(): number;
+    getAvailableToBorrow(): number;
+    getInitialAvailableToWithdraw(): number;
+    getAvailableToWithdraw(): number;
+    getBorrowRate(): number;
+    getSupplyRate(): number;
+    getBorrowAPR(): number;
+    getSupplyAPR(): number;
+    /**
+     * PUBLIC SETTERS
+     */
+    supply(amount: number): void;
+    withdraw(amount: number): void;
+    borrow(amount: number): void;
+    repay(amount: number): void;
+}

package/lib/utils/borrowable/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Borrowable = void 0;
+const index_1 = require("../index");
+class Borrowable {
+    constructor(params) {
+        this.totalSupply = params.totalSupply;
+        this.initialTotalSupply = params.totalSupply;
+        this.totalBorrows = params.totalBorrows;
+        this.initialTotalBorrows = params.totalBorrows;
+        this.kinkRate = params.kinkRate;
+        this.kinkUtilizationRate = params.kinkUtilizationRate;
+        this.kinkMultiplier = params.kinkMultiplier;
+        this.reserveFactor = params.reserveFactor;
+    }
+    /**
+     * PUBLIC GETTERS
+     */
+    getInitialUtilizationRate() {
+        if (this.initialTotalSupply === 0)
+            return 0;
+        return this.initialTotalBorrows / this.initialTotalSupply;
+    }
+    getUtilizationRate() {
+        if (this.totalSupply === 0)
+            return 0;
+        return this.totalBorrows / this.totalSupply;
+    }
+    getInitialAvailableToBorrow() {
+        return this.initialTotalSupply - this.initialTotalBorrows;
+    }
+    getAvailableToBorrow() {
+        return this.totalSupply - this.totalBorrows;
+    }
+    getInitialAvailableToWithdraw() {
+        return this.initialTotalSupply - this.initialTotalBorrows;
+    }
+    getAvailableToWithdraw() {
+        return this.totalSupply - this.totalBorrows;
+    }
+    getBorrowRate() {
+        const utilizationRate = this.getUtilizationRate();
+        if (utilizationRate <= this.kinkUtilizationRate) {
+            return this.kinkRate * utilizationRate / this.kinkUtilizationRate;
+        }
+        else {
+            const overUtil = (utilizationRate - this.kinkUtilizationRate) / (1 - this.kinkUtilizationRate);
+            return this.kinkRate * ((this.kinkMultiplier - 1) * overUtil + 1);
+        }
+    }
+    getSupplyRate() {
+        return this.getBorrowRate() * this.getUtilizationRate() * (1 - this.reserveFactor);
+    }
+    getBorrowAPR() {
+        return (0, index_1.toAPR)(this.getBorrowRate());
+    }
+    getSupplyAPR() {
+        return (0, index_1.toAPR)(this.getSupplyRate());
+    }
+    /**
+     * PUBLIC SETTERS
+     */
+    supply(amount) {
+        this.totalSupply = this.initialTotalSupply + amount;
+    }
+    withdraw(amount) {
+        if (amount > this.getInitialAvailableToWithdraw()) {
+            throw new Error("Trying to withdraw more than available liquidity");
+        }
+        else {
+            this.totalSupply = this.initialTotalSupply - amount;
+        }
+    }
+    borrow(amount) {
+        if (amount > this.getInitialAvailableToBorrow()) {
+            throw new Error("Trying to borrow more than available liquidity");
+        }
+        else {
+            this.totalBorrows = this.initialTotalBorrows + amount;
+        }
+    }
+    repay(amount) {
+        this.totalBorrows = Math.max(this.initialTotalBorrows - amount, 0);
+    }
+}
+exports.Borrowable = Borrowable;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impermax-sdk",
-  "version": "2.1.259",
+  "version": "2.1.261",
   "description": "",
   "main": "./lib/index.js",
   "module": "./lib/index.js",