impermax-sdk 2.1.545 → 2.1.546

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

@@ -3,6 +3,7 @@ import { Address, Borrowable } from "../../config/types";
 import OffchainPoolToken from "../offchainPoolToken";
 import OffchainLendingPool from "./offchainLendingPool";
 import { BorrowableEntity } from "../../utils/borrowable/borrowableEntity";
+import { OffchainLendingVault } from "../vault";
 export default class OffchainBorrowable extends OffchainPoolToken {
     protected readonly lendingPool: OffchainLendingPool;
     protected readonly borrowable: Borrowable;
@@ -44,4 +45,10 @@ export default class OffchainBorrowable extends OffchainPoolToken {
     getTokenPriceAccurate(): Promise<number>;
     private getAccrueFactor;
     getCurrentExchangeRate(): Promise<number>;
+    getMaxFlashAllocate(): Promise<{
+        vault: OffchainLendingVault;
+        amount: number;
+    } | null>;
+    getAvailableToBorrow(): Promise<number>;
+    getAvailableToBorrowUSD(): Promise<number>;
 }

package/lib/offchain/lendingPool/offchainBorrowable.js

@@ -285,5 +285,35 @@ class OffchainBorrowable extends offchainPoolToken_1.default {
         const accrueFactor = await this.getAccrueFactor();
         return lastExchangeRate * accrueFactor;
     }
+    async getMaxFlashAllocate() {
+        const vaults = await this.getOffchain().getVaultsLinkedToBorrowable(this);
+        let bestAmount = 0;
+        let bestVault = null;
+        for (const vault of vaults) {
+            const amount = await vault.getMaxFlashAllocate(await this.getPoolTokenAddress());
+            if (amount > bestAmount) {
+                bestVault = vault;
+                bestAmount = amount;
+            }
+        }
+        if (!bestVault)
+            return null;
+        return {
+            vault: bestVault,
+            amount: bestAmount
+        };
+    }
+    async getAvailableToBorrow() {
+        const totalBalance = await this.getTotalBalance();
+        const maxFlashAllocate = await this.getMaxFlashAllocate();
+        if (maxFlashAllocate)
+            return totalBalance + maxFlashAllocate.amount;
+        return totalBalance;
+    }
+    async getAvailableToBorrowUSD() {
+        const availableToBorrow = await this.getAvailableToBorrow();
+        const tokenPrice = await this.getTokenPriceFast();
+        return availableToBorrow * tokenPrice;
+    }
 }
 exports.default = OffchainBorrowable;

package/lib/offchain/offchain.d.ts

@@ -1,20 +1,21 @@
 import * as initializer from './initializer';
-import OffchainLendingPool from './lendingPool';
+import OffchainLendingPool, { OffchainBorrowable } from './lendingPool';
 import OffchainSolidexHelper from './offchainSolidexHelper';
 import OffchainAccount from './account';
-import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex, Networks, WhitelistState, Extension } from '../config/types';
-import { LendingPoolData, VaultData, VaultPosition, TvlData, UserData, XIbexData, NftlpData, PoolChart, NewlyEarnedFees, NftlpStats, XIbexUserData, NewlyEarnedReward, NetworkTokenData } from './offchainTypes';
+import { Address, AddressIndex, Extension, Factory, FactoryIndex, LendingPoolIndex, Networks, WhitelistState } from '../config/types';
+import { LendingPoolData, NetworkTokenData, NewlyEarnedFees, NewlyEarnedReward, NftlpData, NftlpStats, PoolChart, TvlData, UserData, VaultData, VaultPosition, XIbexData, XIbexUserData } from './offchainTypes';
 import OffchainVault from './vault/offchainVault';
 import OffchainConfigManager from './configManager';
 import OffchainConfigManagerV3 from './configManager/v3';
 import { PairState } from '../config/whitelist';
 import OffchainStakingModule from './staking/offchainStakingModule';
+import OffchainMultichain from "./offchainMultichain";
+import { OffchainLendingVault } from "./vault";
 export interface OffchainCfg {
     network: Networks;
     chainId: number;
     whitelistedPairs?: FactoryIndex<Address[]>;
 }
-import OffchainMultichain from "./offchainMultichain";
 export default class Offchain {
     readonly offchainMultichain: OffchainMultichain;
     readonly network: Networks;
@@ -44,6 +45,9 @@ export default class Offchain {
     protected vaultsUsersData: {
         [key in Address]?: Promise<AddressIndex<AddressIndex<VaultPosition>>>;
     };
+    protected vaultsLinkToBorrowable: {
+        [key in Address]: Promise<Array<OffchainLendingVault>>;
+    };
     protected borrowersList: Promise<OffchainAccount[]> | null;
     protected stakingModule: OffchainStakingModule;
     protected xibexUsersData: {
@@ -125,4 +129,7 @@ export default class Offchain {
     protected initializeNftlpsData: typeof initializer.initializeNftlpsData;
     getPairsList(factory: Factory, state?: PairState): Address[];
     getNetworkTokens(): Promise<NetworkTokenData[]>;
+    getVaultList(): Promise<OffchainVault[]>;
+    private _getVaultsLinkedToBorrowable;
+    getVaultsLinkedToBorrowable(borrowable: OffchainBorrowable): Promise<OffchainLendingVault[]>;
 }

package/lib/offchain/offchain.js

@@ -136,6 +136,7 @@ class Offchain {
         this.usersData = {};
         this.vaultsUsersData = {};
         this.xibexUsersData = {};
+        this.vaultsLinkToBorrowable = {};
         // Staking module is only available on Arbitrum atm, 
         // so we initialize it once in the offchainMultichain.
         // this.stakingModule = new OffchainStakingModule(this);
@@ -159,6 +160,7 @@ class Offchain {
         this.userNewlyEarnedFeesData = {};
         this.userNewlyEarnedRewardData = {};
         this.xibexUsersData = {};
+        this.vaultsLinkToBorrowable = {};
         this.stakingModule?.cleanCache();
         for (const address in this.accounts) {
             await this.accounts[address].cleanCache();
@@ -272,5 +274,29 @@ class Offchain {
             return [];
         }
     }
+    async getVaultList() {
+        return this.offchainMultichain.getVaultList({ networks: [this.network] });
+    }
+    async _getVaultsLinkedToBorrowable(borrowable) {
+        const result = [];
+        const underlying = await borrowable.getUnderlyingAddress();
+        const vaults = await this.getVaultList();
+        for (const vault of vaults) {
+            if (vault.getVaultType() !== types_1.VaultType.LENDING)
+                continue;
+            if (await vault.getUnderlyingAddress() === underlying) {
+                const id = await vault.getBorrowableId(await borrowable.getPoolTokenAddress());
+                if (id !== null)
+                    result.push(vault);
+            }
+        }
+        return result;
+    }
+    async getVaultsLinkedToBorrowable(borrowable) {
+        const borrowableAddress = await borrowable.getPoolTokenAddress();
+        if (!this.vaultsLinkToBorrowable[borrowableAddress])
+            this.vaultsLinkToBorrowable[borrowableAddress] = this._getVaultsLinkedToBorrowable(borrowable);
+        return this.vaultsLinkToBorrowable[borrowableAddress];
+    }
 }
 exports.default = Offchain;

package/lib/offchain/offchainPoolToken.d.ts

@@ -12,6 +12,7 @@ export default abstract class OffchainPoolToken {
     getSymbol(): Promise<string>;
     getDecimals(): Promise<number>;
     getExchangeRate(): Promise<number>;
+    getPoolTokenAddress(): Promise<Address>;
     getUnderlyingAddress(): Promise<Address>;
     getTotalBalance(): Promise<number>;
     getTotalBalanceUSD(): Promise<number>;

package/lib/offchain/offchainPoolToken.js

@@ -63,6 +63,10 @@ class OffchainPoolToken {
         return this.getPoolTokenParamFloat("exchangeRate");
     }
     // Underlying Address
+    async getPoolTokenAddress() {
+        return this.getPoolTokenParam("id");
+    }
+    // Underlying Address
     async getUnderlyingAddress() {
         return this.getUnderlyingParam("id");
     }

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

@@ -13,6 +13,9 @@ export declare enum RiskLevel {
 export default class OffchainLendingVault extends OffchainVault {
     protected cache: {
         lendingVaultObject?: Promise<LendingVaultEntity>;
+        maxFlashAllocate?: {
+            [key in Address]: Promise<number>;
+        };
     };
     protected vaultBorrowables: Array<VaultBorrowable> | null;
     constructor(offchain: Offchain, vaultAddress: Address);
@@ -26,4 +29,7 @@ export default class OffchainLendingVault extends OffchainVault {
     getAccountBorrowables(): Promise<Array<OffchainAccountBorrowable>>;
     getBorrowables(): Promise<Array<VaultBorrowable>>;
     getLendingVaultBorrowables(): Promise<Array<VaultBorrowable>>;
+    getBorrowableId(borrowableAddress: Address): Promise<number | null>;
+    private _getMaxFlashAllocate;
+    getMaxFlashAllocate(borrowableAddress: Address): Promise<number>;
 }

package/lib/offchain/vault/offchainLendingVault.js

@@ -131,5 +131,28 @@ class OffchainLendingVault extends offchainVault_1.default {
         this.vaultBorrowables = await this.getBorrowables();
         return this.vaultBorrowables;
     }
+    async getBorrowableId(borrowableAddress) {
+        const borrowables = await this.getLendingVaultBorrowables();
+        for (let i = 0; i < borrowables.length; i++) {
+            if (borrowables[i].address.toLowerCase() === borrowableAddress.toLowerCase()) {
+                return i;
+            }
+        }
+        return null;
+    }
+    async _getMaxFlashAllocate(borrowableAddress) {
+        const id = await this.getBorrowableId(borrowableAddress);
+        // TODO return 0 if disabled
+        if (id === null)
+            return 0;
+        return (await this.getLendingVaultObject()).getMaxFlashAllocate(id);
+    }
+    async getMaxFlashAllocate(borrowableAddress) {
+        if (!this.cache.maxFlashAllocate)
+            this.cache.maxFlashAllocate = {};
+        if (!this.cache.maxFlashAllocate[borrowableAddress])
+            this.cache.maxFlashAllocate[borrowableAddress] = this._getMaxFlashAllocate(borrowableAddress);
+        return this.cache.maxFlashAllocate[borrowableAddress];
+    }
 }
 exports.default = OffchainLendingVault;

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

@@ -27,8 +27,6 @@ class OnchainInteractionsNftlp {
      * Utilities
      */
     encodeActions(actions = []) {
-        console.log("actions");
-        console.log(actions);
         return ethers_1.ethers.utils.defaultAbiCoder.encode(['tuple(uint256 actionType, bytes actionData, bytes nextAction)[]'], [actions]);
     }
 }

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

@@ -70,12 +70,24 @@ class OnchainInteractionsNftlpGenericCL extends onchainInteractionsNftlp_1.defau
         const isEthB = await borrowableB.isETH();
         // Vault flash allocate
         // TODO understand when to flashallocate, and how much
-        const ethVault = this.getNftlp().getLendingPool().getImpermaxFactory().getOnchain().getLendingVault("0x0988cc53b8ddd625c20e382f1af2f9c385e4f9a3");
+        // if we reallocate always reallocate all the available liquidity, in order to make sure we have enough
+        /*const ethVault = this.getNftlp().getLendingPool().getImpermaxFactory().getOnchain().getLendingVault("0x0988cc53b8ddd625c20e382f1af2f9c385e4f9a3")
         const availableLiquidity0 = await ethVault.getAvailableLiquidity() * 0.9;
-        const usdcVault = this.getNftlp().getLendingPool().getImpermaxFactory().getOnchain().getLendingVault("0xf7408ba0aaf8ca80d4442731415bbe2156da8958");
+    
+        const usdcVault = this.getNftlp().getLendingPool().getImpermaxFactory().getOnchain().getLendingVault("0xf7408ba0aaf8ca80d4442731415bbe2156da8958")
         const availableLiquidity1 = await usdcVault.getAvailableLiquidity() * 0.9;
-        actions.push(await actionsGetter.methods.getFlashAllocateAction("0", "0x0988cc53b8ddd625c20e382f1af2f9c385e4f9a3", await borrowableA.toBigNumber(availableLiquidity0)).call());
-        actions.push(await actionsGetter.methods.getFlashAllocateAction("1", "0xf7408ba0aaf8ca80d4442731415bbe2156da8958", await borrowableB.toBigNumber(availableLiquidity1)).call());
+    
+        actions.push(await actionsGetter.methods.getFlashAllocateAction(
+          "0",
+          "0x0988cc53b8ddd625c20e382f1af2f9c385e4f9a3",
+          await borrowableA.toBigNumber(availableLiquidity0)
+        ).call())
+    
+        actions.push(await actionsGetter.methods.getFlashAllocateAction(
+          "1",
+          "0xf7408ba0aaf8ca80d4442731415bbe2156da8958",
+          await borrowableB.toBigNumber(availableLiquidity1)
+        ).call())*/
         // Borrow and mint
         if ((borrowADelta > 0 && depositADelta > 0) || (borrowBDelta > 0 && depositBDelta > 0)) {
             // slightly increase borrowDelta in order to avoid amountUser to be dust

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

@@ -37,10 +37,10 @@ class BorrowableEntity {
     // TODO implement debt ceiling
     // TODO implement flash allocate
     getInitialAvailableToBorrow() {
-        return this.initialTotalSupply - this.initialTotalBorrows + 1e9;
+        return this.initialTotalSupply - this.initialTotalBorrows;
     }
     getAvailableToBorrow() {
-        return this.totalSupply - this.totalBorrows + 1e9;
+        return this.totalSupply - this.totalBorrows;
     }
     getInitialAvailableToWithdraw() {
         return this.initialTotalSupply - this.initialTotalBorrows;

package/lib/utils/vault/lendingVaultEntity/index.d.ts

@@ -30,4 +30,5 @@ export declare class LendingVaultEntity {
     supply(amount: number, relative?: boolean): void;
     withdraw(amount: number, relative?: boolean): void;
     reallocate(withdrawAmount?: number): void;
+    getMaxFlashAllocate(borrowable: number): number;
 }

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

@@ -17,7 +17,6 @@ class LendingVaultEntity {
         else
             this.state++;
     }
-    // TODO recreate reallocate algorithm
     /**
      * PUBLIC GETTERS
      */
@@ -132,5 +131,11 @@ class LendingVaultEntity {
             this.totalBalance -= amount;
         }
     }
+    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
+    }
 }
 exports.LendingVaultEntity = LendingVaultEntity;

package/package.json

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