impermax-sdk 2.1.550 → 2.1.552

package/lib/offchain/lendingPool/offchainBorrowable.d.ts

@@ -48,6 +48,7 @@ export default class OffchainBorrowable extends OffchainPoolToken {
     getMaxFlashAllocate(): Promise<{
         vault: OffchainLendingVault;
         amount: number;
+        availableToWithdraw: number;
     } | null>;
     getAvailableToBorrow(): Promise<number>;
     getAvailableToBorrowUSD(): Promise<number>;

package/lib/offchain/lendingPool/offchainBorrowable.js

@@ -291,18 +291,22 @@ class OffchainBorrowable extends offchainPoolToken_1.default {
         const vaults = await this.getOffchain().getVaultsLinkedToBorrowable(this);
         let bestAmount = 0;
         let bestVault = null;
+        let availableToWithdraw = 0;
+        const poolTokenAddress = await this.getPoolTokenAddress();
         for (const vault of vaults) {
-            const amount = await vault.getMaxFlashAllocate(await this.getPoolTokenAddress());
+            const amount = await vault.getMaxFlashAllocate(poolTokenAddress);
             if (amount > bestAmount) {
                 bestVault = vault;
                 bestAmount = amount;
+                availableToWithdraw = await vault.getAvailableToWithdraw(poolTokenAddress);
             }
         }
         if (bestVault === null)
             return null;
         return {
             vault: bestVault,
-            amount: bestAmount
+            amount: bestAmount,
+            availableToWithdraw
         };
     }
     async getAvailableToBorrow() {

package/lib/offchain/vault/offchainLendingVault.d.ts

@@ -16,6 +16,9 @@ export default class OffchainLendingVault extends OffchainVault {
         maxFlashAllocate?: {
             [key in Address]: Promise<number>;
         };
+        availableToWithdraw?: {
+            [key in Address]: Promise<number>;
+        };
     };
     protected vaultBorrowables: Array<VaultBorrowable> | null;
     constructor(offchain: Offchain, vaultAddress: Address);
@@ -32,4 +35,6 @@ export default class OffchainLendingVault extends OffchainVault {
     getBorrowableId(borrowableAddress: Address): Promise<number | null>;
     private _getMaxFlashAllocate;
     getMaxFlashAllocate(borrowableAddress: Address): Promise<number>;
+    private _getAvailableToWithdraw;
+    getAvailableToWithdraw(borrowableAddress: Address): Promise<number>;
 }

package/lib/offchain/vault/offchainLendingVault.js

@@ -154,5 +154,18 @@ class OffchainLendingVault extends offchainVault_1.default {
             this.cache.maxFlashAllocate[borrowableAddress] = this._getMaxFlashAllocate(borrowableAddress);
         return this.cache.maxFlashAllocate[borrowableAddress];
     }
+    async _getAvailableToWithdraw(borrowableAddress) {
+        const id = await this.getBorrowableId(borrowableAddress);
+        if (id === null)
+            return 0;
+        return (await this.getLendingVaultObject()).positions[id].getInitialAvailableToWithdraw();
+    }
+    async getAvailableToWithdraw(borrowableAddress) {
+        if (!this.cache.availableToWithdraw)
+            this.cache.availableToWithdraw = {};
+        if (!this.cache.availableToWithdraw[borrowableAddress])
+            this.cache.availableToWithdraw[borrowableAddress] = this._getAvailableToWithdraw(borrowableAddress);
+        return this.cache.availableToWithdraw[borrowableAddress];
+    }
 }
 exports.default = OffchainLendingVault;

package/lib/onchain/interactions/lendingPool/nftlp/onchainInteractionsNftlpGenericCL.js

@@ -73,14 +73,14 @@ class OnchainInteractionsNftlpGenericCL extends onchainInteractionsNftlp_1.defau
         const maxFlashAllocateA = await offchainBorrowableA.getMaxFlashAllocate();
         if (maxFlashAllocateA) {
             if (borrowADelta > await offchainBorrowableA.getTotalBalance()) {
-                actions.push(await actionsGetter.methods.getFlashAllocateAction("0", maxFlashAllocateA.vault.getVaultAddress(), await borrowableA.toBigNumber(maxFlashAllocateA.amount)).call());
+                actions.push(await actionsGetter.methods.getFlashAllocateAction("0", maxFlashAllocateA.vault.getVaultAddress(), await borrowableA.toBigNumber(maxFlashAllocateA.amount + maxFlashAllocateA.availableToWithdraw)).call());
             }
         }
         const offchainBorrowableB = await borrowableB.getOffchainBorrowable();
         const maxFlashAllocateB = await offchainBorrowableB.getMaxFlashAllocate();
         if (maxFlashAllocateB) {
             if (borrowBDelta > await offchainBorrowableB.getTotalBalance()) {
-                actions.push(await actionsGetter.methods.getFlashAllocateAction("1", maxFlashAllocateB.vault.getVaultAddress(), await borrowableB.toBigNumber(maxFlashAllocateB.amount)).call());
+                actions.push(await actionsGetter.methods.getFlashAllocateAction("1", maxFlashAllocateB.vault.getVaultAddress(), await borrowableB.toBigNumber(maxFlashAllocateB.amount + maxFlashAllocateB.availableToWithdraw)).call());
             }
         }
         // Borrow and mint

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

@@ -31,6 +31,8 @@ export declare class BorrowableEntity {
     getAvailableToBorrow(): number;
     getInitialAvailableToWithdraw(): number;
     getAvailableToWithdraw(): number;
+    calculateBorrowRateForUtilization(utilizationRate: number): number;
+    calculateSupplyRateForUtilization(utilizationRate: number): number;
     getBorrowRate(): number;
     getSupplyRate(): number;
     getBorrowAPR(): number;

package/lib/utils/borrowable/borrowableEntity/index.js

@@ -49,8 +49,7 @@ class BorrowableEntity {
     getAvailableToWithdraw() {
         return Math.max(this.totalSupply - this.totalBorrows, 0);
     }
-    getBorrowRate() {
-        const utilizationRate = this.getUtilizationRate();
+    calculateBorrowRateForUtilization(utilizationRate) {
         if (utilizationRate <= this.kinkUtilizationRate) {
             return this.kinkBorrowRate * utilizationRate / this.kinkUtilizationRate;
         }
@@ -59,8 +58,15 @@ class BorrowableEntity {
             return this.kinkBorrowRate * ((this.kinkMultiplier - 1) * overUtil + 1);
         }
     }
+    calculateSupplyRateForUtilization(utilizationRate) {
+        const borrowRate = this.calculateBorrowRateForUtilization(utilizationRate);
+        return borrowRate * utilizationRate * (1 - this.reserveFactor);
+    }
+    getBorrowRate() {
+        return this.calculateBorrowRateForUtilization(this.getUtilizationRate());
+    }
     getSupplyRate() {
-        return this.getBorrowRate() * this.getUtilizationRate() * (1 - this.reserveFactor);
+        return this.calculateSupplyRateForUtilization(this.getUtilizationRate());
     }
     getBorrowAPR() {
         return (0, index_1.toAPR)(this.getBorrowRate());

package/lib/utils/vault/lendingVaultEntity/index.js

@@ -132,10 +132,26 @@ class LendingVaultEntity {
         }
     }
     getMaxFlashAllocate(borrowable) {
-        // TODO dynamically calculate this
-        const amountToExclude = this.positions[borrowable].getInitialAvailableToWithdraw();
-        return (this.getAvailableLiquidity() - amountToExclude) * 0.99;
-        // TODO questa è l'aggiunta, ma devo callare sommando anche initial amount... mmmmh
+        let maxFlashAllocate = 0;
+        const maxRate = this.positions[borrowable].borrowable.calculateSupplyRateForUtilization(1);
+        for (let i = 0; i < this.positions.length; i++) {
+            if (i === borrowable)
+                continue;
+            const b = this.positions[i].borrowable;
+            const maxWithdrawable = this.positions[i].getInitialAvailableToWithdraw();
+            const targetUtilizationRate = b.calculateUtilizationForRate(maxRate);
+            if (targetUtilizationRate > 1) {
+                maxFlashAllocate += maxWithdrawable;
+                continue;
+            }
+            const targetSupply = b.initialTotalBorrows / targetUtilizationRate;
+            // notice: supply delta CAN be negative
+            // in this case we have to consider that the vault will have to deposit
+            // liquidity in this pool instead of withdrawing it
+            const supplyDelta = b.totalSupply - targetSupply;
+            maxFlashAllocate += Math.min(maxWithdrawable, supplyDelta);
+        }
+        return Math.max(maxFlashAllocate * 0.99, 0);
     }
 }
 exports.LendingVaultEntity = LendingVaultEntity;

package/package.json

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