@augustdigital/sdk 4.1.0-alpha → 4.1.0

package/lib/modules/vaults/main.js

@@ -1,28 +1,56 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AugustVaults = void 0;
-const utils_1 = require("./utils");
+__exportStar(require("./getters"), exports);
+const fetcher_1 = require("./fetcher");
 const ethers_1 = require("ethers");
 const getters_1 = require("./getters");
 const vaults_1 = require("../../services/subgraph/vaults");
 const core_1 = require("../../core");
 const solana_1 = require("../../adapters/solana");
-const user_actions_1 = require("./user.actions");
+const sui_1 = __importDefault(require("../../adapters/sui"));
 class AugustVaults extends core_1.AugustBase {
-    constructor(baseConfig, solana) {
+    constructor(baseConfig, solana, sui) {
         super(baseConfig);
+        this.headers = null;
         this.solanaService = solana;
-    }
-    async getVaults(options) {
-        const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, {
+        this.suiService = sui || new sui_1.default();
+        this.headers = {
             'x-environment': this.monitoring?.['x-environment'],
             'x-user-id': this.monitoring?.['x-user-id'],
-        });
+        };
+    }
+    async getVaults(options) {
+        const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, this.headers);
         const vaultsPerAvailableProviders = allVaults.filter((v) => !!this.providers?.[v?.chain] ? true : false);
         const vaultsPerChainId = options?.chainIds
             ? vaultsPerAvailableProviders.filter((v) => options.chainIds.includes(v.chain))
             : vaultsPerAvailableProviders;
-        const vaultFetchResult = await (0, utils_1.fetchVaultsComprehensive)(vaultsPerChainId, async (vault) => {
+        const emberVaults = await this.suiService.getEmberVaults({
+            status: 'active',
+        });
+        const activeEmberVaults = Array.isArray(emberVaults)
+            ? emberVaults.filter((v) => v?.status === 'active')
+            : [];
+        const transformedVaults = this.suiService.transformEmberVaultsToIVaults(activeEmberVaults);
+        const vaultFetchResult = await (0, fetcher_1.fetchVaultsComprehensive)(vaultsPerChainId, async (vault) => {
             const rpcUrl = vault.fallbackRpc || this.providers?.[vault.chain];
             const shouldFetchLoans = !vault.minimal &&
                 (typeof options?.loans !== 'undefined' ? options?.loans : true);
@@ -33,7 +61,7 @@ class AugustVaults extends core_1.AugustBase {
             const isSolana = solana_1.Solana.utils.isSolanaAddress(vault.address)
                 ? true
                 : false;
-            const v = (0, getters_1.getVault)({
+            const v = await (0, getters_1.getVault)({
                 vault: vault.address,
                 loans: isSolana ? false : shouldFetchLoans,
                 allocations: isSolana ? false : shouldFetchAllocations,
@@ -63,13 +91,12 @@ class AugustVaults extends core_1.AugustBase {
                 137: (0, core_1.getFallbackRpcUrls)(137),
             },
         });
-        console.log(`Vault fetching results:`);
-        console.log(`- Total vaults: ${vaultFetchResult.coverageReport.totalVaults}`);
-        console.log(`- Successfully fetched: ${vaultFetchResult.coverageReport.successfulVaults}`);
-        console.log(`- Failed to fetch: ${vaultFetchResult.coverageReport.failedVaults}`);
-        console.log(`- Success rate: ${vaultFetchResult.successRate.toFixed(2)}%`);
+        core_1.Logger.log.info('getVaults', `Total: ${vaultFetchResult.coverageReport.totalVaults}, ` +
+            `Success: ${vaultFetchResult.coverageReport.successfulVaults}, ` +
+            `Failed: ${vaultFetchResult.coverageReport.failedVaults}, ` +
+            `Rate: ${vaultFetchResult.successRate.toFixed(2)}%`);
         if (vaultFetchResult.coverageReport.failedVaults > 0) {
-            console.warn('Failed vaults:', vaultFetchResult.failed.map((f) => ({
+            core_1.Logger.log.warn('getVaults:failed', vaultFetchResult.failed.map((f) => ({
                 address: f.address,
                 chain: f.chain,
                 error: f.error.message,
@@ -79,20 +106,15 @@ class AugustVaults extends core_1.AugustBase {
         const vaultResponses = vaultFetchResult.successful
             .sort((a, b) => a.index - b.index)
             .map((item) => item.data);
-        const filteredResults = (0, utils_1.filterVaultsIntelligently)(vaultResponses, {
+        const filteredResults = (0, fetcher_1.filterVaultsIntelligently)(vaultResponses, {
             includeClosed: true,
             includeInvisible: true,
             minStatus: ['active', 'closed'],
         });
-        if (this.monitoring?.env === 'DEV') {
-            console.log(`Vault filtering results:`);
-            console.log(`- Active vaults: ${filteredResults.summary.active}`);
-            console.log(`- Closed vaults: ${filteredResults.summary.closed}`);
-            console.log(`- Invisible vaults: ${filteredResults.summary.invisible}`);
-            console.log(`- Filtered out: ${filteredResults.summary.failed}`);
-            console.log(`- Overall success rate: ${filteredResults.summary.successRate.toFixed(2)}%`);
-        }
-        const filteredResponses = filteredResults.active;
+        const filteredResponses = [
+            ...filteredResults.active,
+            ...filteredResults.invisible,
+        ];
         if ((options.wallet && (0, ethers_1.isAddress)(options.wallet)) ||
             (options.solanaWallet &&
                 solana_1.Solana.utils.isSolanaAddress(options.solanaWallet))) {
@@ -116,16 +138,19 @@ class AugustVaults extends core_1.AugustBase {
                 position: positions?.find((pos) => pos.vault?.toLowerCase() === r.address?.toLowerCase()) || null,
             }));
         }
-        if (!!options.wallet && !(0, ethers_1.isAddress)(options.wallet))
-            console.warn('#getVaults: wallet passed is not of type address');
-        return filteredResponses;
+        if (!!options.wallet && !(0, ethers_1.isAddress)(options.wallet)) {
+            core_1.Logger.log.warn('getVaults:invalid_wallet', options.wallet);
+        }
+        return [...filteredResponses, ...transformedVaults];
     }
     async getVault({ vault, chainId, options, }) {
         if (!vault)
             throw new Error('Vault input parameter is undefined.');
         if (typeof chainId !== 'undefined') {
-            if (!this.providers?.[chainId])
-                console.error('#getVault:', 'missing rpcUrl in initialization for chainId', chainId);
+            if (!this.providers?.[chainId]) {
+                const error = new Error(`Missing RPC URL for chainId ${chainId}`);
+                core_1.Logger.log.error('getVault:missing_provider', error, { chainId });
+            }
         }
         const vaultResponse = await (0, getters_1.getVault)({
             vault: vault,
@@ -139,20 +164,17 @@ class AugustVaults extends core_1.AugustBase {
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
-                headers: {
-                    'x-environment': this.monitoring?.['x-environment'],
-                    'x-user-id': this.monitoring?.['x-user-id'],
-                },
+                headers: this.headers,
             },
         });
         if ((0, ethers_1.isAddress)(vault) &&
-            ((options.wallet && (0, ethers_1.isAddress)(options.wallet)) ||
-                (options.solanaWallet &&
-                    solana_1.Solana.utils.isSolanaAddress(options.solanaWallet)))) {
+            ((options?.wallet && (0, ethers_1.isAddress)(options?.wallet)) ||
+                (options?.solanaWallet &&
+                    solana_1.Solana.utils.isSolanaAddress(options?.solanaWallet)))) {
             const vaultResponses = await (0, getters_1.getVaultPositions)({
                 vault: vault,
-                solanaWallet: options.solanaWallet,
-                wallet: options.wallet,
+                solanaWallet: options?.solanaWallet,
+                wallet: options?.wallet,
                 options: {
                     rpcUrl: chainId
                         ? this.providers?.[chainId]
@@ -161,10 +183,7 @@ class AugustVaults extends core_1.AugustBase {
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                     subgraphKey: this.keys?.graph,
-                    headers: {
-                        'x-environment': this.monitoring?.['x-environment'],
-                        'x-user-id': this.monitoring?.['x-user-id'],
-                    },
+                    headers: this.headers,
                 },
             });
             const positions = vaultResponses.filter((v) => v.status !== 'PENDING');
@@ -173,8 +192,9 @@ class AugustVaults extends core_1.AugustBase {
                 position: positions?.find((pos) => pos.vault?.toLowerCase() === vault?.toLowerCase()) || null,
             };
         }
-        if (!!options.wallet && !(0, ethers_1.isAddress)(options.wallet))
-            console.warn('#getVaults: wallet passed is not of type address');
+        if (!!options?.wallet && !(0, ethers_1.isAddress)(options?.wallet)) {
+            core_1.Logger.log.warn('getVault:invalid_wallet', options?.wallet);
+        }
         return vaultResponse;
     }
     async getVaultLoans({ vault, chainId, }) {
@@ -183,8 +203,10 @@ class AugustVaults extends core_1.AugustBase {
         if (!(0, ethers_1.isAddress)(vault))
             throw new Error(`Vault input parameter is not an address: ${String(vault)}`);
         if (typeof chainId !== 'undefined') {
-            if (!this.providers?.[chainId])
-                console.error('#getVaultLoans:', 'missing rpcUrl in initialization for chainId', chainId);
+            if (!this.providers?.[chainId]) {
+                const error = new Error(`Missing RPC URL for chainId ${chainId}`);
+                core_1.Logger.log.error('getVaultLoans:missing_provider', error, { chainId });
+            }
         }
         const vaultResponse = await (0, getters_1.getVaultLoans)(vault, {
             rpcUrl: chainId ? this.providers?.[chainId] : this.activeNetwork.rpcUrl,
@@ -193,10 +215,7 @@ class AugustVaults extends core_1.AugustBase {
             subgraphKey: this.keys?.graph,
             chainId: chainId,
             solanaService: this.solanaService,
-            headers: {
-                'x-environment': this.monitoring?.['x-environment'],
-                'x-user-id': this.monitoring?.['x-user-id'],
-            },
+            headers: this.headers,
         });
         return vaultResponse;
     }
@@ -206,8 +225,12 @@ class AugustVaults extends core_1.AugustBase {
         if (!(0, ethers_1.isAddress)(vault))
             throw new Error(`Vault input parameter is not an address: ${String(vault)}`);
         if (typeof chainId !== 'undefined') {
-            if (!this.providers?.[chainId])
-                console.error('#getVaultAllocations:', 'missing rpcUrl in initialization for chainId', chainId);
+            if (!this.providers?.[chainId]) {
+                const error = new Error(`Missing RPC URL for chainId ${chainId}`);
+                core_1.Logger.log.error('getVaultAllocations:missing_provider', error, {
+                    chainId,
+                });
+            }
         }
         try {
             const vaultResponse = await (0, getters_1.getVaultAllocations)(vault, {
@@ -216,10 +239,7 @@ class AugustVaults extends core_1.AugustBase {
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
-                headers: {
-                    'x-environment': this.monitoring?.['x-environment'],
-                    'x-user-id': this.monitoring?.['x-user-id'],
-                },
+                headers: this.headers,
             });
             return vaultResponse;
         }
@@ -237,24 +257,22 @@ class AugustVaults extends core_1.AugustBase {
             };
         }
     }
-    async getVaultApy(vault) {
+    async getVaultApy({ vault, historical, }) {
         if (!vault)
             throw new Error('Vault input parameter is undefined.');
         if (!(0, ethers_1.isAddress)(vault))
             throw new Error(`Vault input parameter is not an address: ${String(vault)}`);
         return await (0, getters_1.getVaultApy)({
             vault,
+            historical,
             options: {
                 rpcUrl: this.activeNetwork.rpcUrl,
                 subgraphKey: this.keys?.graph,
-                headers: {
-                    'x-environment': this.monitoring?.['x-environment'],
-                    'x-user-id': this.monitoring?.['x-user-id'],
-                },
+                headers: this.headers,
             },
         });
     }
-    async getAvailableRedemptions({ vault, chainId, wallet, }) {
+    async getVaultAvailableRedemptions({ vault, chainId, wallet, }) {
         if (!this.authorized)
             throw new Error('Not authorized.');
         if (!vault)
@@ -270,16 +288,13 @@ class AugustVaults extends core_1.AugustBase {
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
-                headers: {
-                    'x-environment': this.monitoring?.['x-environment'],
-                    'x-user-id': this.monitoring?.['x-user-id'],
-                },
+                headers: this.headers,
             },
         });
     }
-    async getPositions({ vault, wallet, chainId, showAllVaults, solanaWallet, options, }) {
-        if (!wallet && !solanaWallet) {
-            throw new Error('Either wallet (EVM) or solanaWallet parameter must be provided');
+    async getVaultPositions({ vault, wallet, chainId, showAllVaults, solanaWallet, options, }) {
+        if (solanaWallet && !solana_1.Solana.utils.isSolanaAddress(solanaWallet)) {
+            throw new Error('Solana wallet parameter must be provided and be a valid Solana address');
         }
         if (wallet && !(0, ethers_1.isAddress)(wallet)) {
             throw new Error(`Wallet parameter is not a valid address: ${String(wallet)}`);
@@ -297,17 +312,11 @@ class AugustVaults extends core_1.AugustBase {
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                     subgraphKey: this.keys?.graph,
-                    headers: {
-                        'x-environment': this.monitoring?.['x-environment'],
-                        'x-user-id': this.monitoring?.['x-user-id'],
-                    },
+                    headers: this.headers,
                 },
             });
         }
-        const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, {
-            'x-environment': this.monitoring?.['x-environment'],
-            'x-user-id': this.monitoring?.['x-user-id'],
-        });
+        const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, this.headers);
         if (chainId) {
             const vaultsPerChain = allVaults.filter((v) => v.chain === chainId);
             const vaultResponses = await Promise.all(vaultsPerChain.map((v) => (0, getters_1.getVaultPositions)({
@@ -320,10 +329,7 @@ class AugustVaults extends core_1.AugustBase {
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                     subgraphKey: this.keys?.graph,
-                    headers: {
-                        'x-environment': this.monitoring?.['x-environment'],
-                        'x-user-id': this.monitoring?.['x-user-id'],
-                    },
+                    headers: this.headers,
                 },
             })));
             const flattened = vaultResponses.flat();
@@ -332,6 +338,7 @@ class AugustVaults extends core_1.AugustBase {
                 final = flattened;
             else
                 final = flattened.filter((v) => v?.status !== 'PENDING');
+            core_1.Logger.log.info(`getPositions::${chainId || 'all'}:`, final.map((v) => v.vault));
             return final;
         }
         const vaultsPerAvailableProviders = allVaults.filter((v) => !!this.providers?.[v?.chain] ? true : false);
@@ -345,10 +352,7 @@ class AugustVaults extends core_1.AugustBase {
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
-                headers: {
-                    'x-environment': this.monitoring?.['x-environment'],
-                    'x-user-id': this.monitoring?.['x-user-id'],
-                },
+                headers: this.headers,
             },
         })));
         const flattened = vaultResponses.flat();
@@ -359,7 +363,7 @@ class AugustVaults extends core_1.AugustBase {
             final = flattened.filter((v) => v?.status !== 'PENDING');
         return final;
     }
-    async getUserHistory({ wallet, chainId, vault, options, }) {
+    async getUserHistory({ wallet, chainId, vault, }) {
         if (!(0, ethers_1.isAddress)(wallet))
             throw new Error(`Wallet parameter is not an address: ${String(wallet)}`);
         const _chainId = chainId || this.activeNetwork.chainId;
@@ -381,10 +385,7 @@ class AugustVaults extends core_1.AugustBase {
             finalArray = formatHistory(userHistory);
         }
         else {
-            const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, {
-                'x-environment': this.monitoring?.['x-environment'],
-                'x-user-id': this.monitoring?.['x-user-id'],
-            });
+            const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, this.headers);
             if (chainId) {
                 const vaultsPerChain = allVaults.filter((v) => v.chain === chainId);
                 const vaultResponses = await Promise.all(vaultsPerChain.map(async (v) => {
@@ -406,8 +407,7 @@ class AugustVaults extends core_1.AugustBase {
                 finalArray = flattened;
             }
         }
-        if (this.monitoring?.env === 'DEV')
-            console.log(`#getUserHistory:`, finalArray.slice(0, 1));
+        core_1.Logger.log.info('getUserHistory', `${wallet}::${finalArray.length}`);
         return finalArray;
     }
     async getUserTransfers({ wallet, chainId, vault, options, }) {
@@ -432,10 +432,7 @@ class AugustVaults extends core_1.AugustBase {
             finalArray = formatTransfers(userHistory);
         }
         else {
-            const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, {
-                'x-environment': this.monitoring?.['x-environment'],
-                'x-user-id': this.monitoring?.['x-user-id'],
-            });
+            const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, this.headers);
             if (chainId) {
                 const vaultsPerChain = allVaults.filter((v) => v.chain === chainId);
                 const vaultResponses = await Promise.all(vaultsPerChain.map(async (v) => {
@@ -457,8 +454,7 @@ class AugustVaults extends core_1.AugustBase {
                 finalArray = formatTransfers(flattened);
             }
         }
-        if (this.monitoring?.env === 'DEV')
-            console.log(`#getUserTransfers:`, finalArray.slice(0, 1));
+        core_1.Logger.log.info('getUserTransfers', `${wallet}::${finalArray.length}`);
         return finalArray;
     }
     async getStakingPositions(wallet, chainId) {
@@ -479,112 +475,57 @@ class AugustVaults extends core_1.AugustBase {
         }));
         return positions.flat();
     }
-    getVaultExposure(debankResponse) {
-        const borrowing_exposure = [];
-        const supplying_exposure = [];
-        const wallet_exposure = [];
-        const positions = debankResponse?.subaccount?.positions ?? [];
-        const tokens = debankResponse?.subaccount?.tokens ?? [];
-        for (const position of positions) {
-            const portfolioItems = position?.portfolio_item_list ?? [];
-            for (const item of portfolioItems) {
-                const borrowTokens = item?.detail?.borrow_token_list ?? [];
-                const supplyTokens = item?.detail?.supply_token_list ?? [];
-                for (const token of tokens) {
-                    if (token?.symbol && token?.is_core) {
-                        wallet_exposure.push({
-                            symbol: token.symbol,
-                            chain: token.chain,
-                            amount: token.amount * token.price,
-                        });
-                    }
-                }
-                for (const token of borrowTokens) {
-                    if (token?.symbol &&
-                        !token.is_suspicious &&
-                        !token.is_scam &&
-                        token?.is_core) {
-                        borrowing_exposure.push({
-                            symbol: token.symbol,
-                            chain: token.chain,
-                            amount: token.amount * token.price,
-                        });
-                    }
-                }
-                for (const token of supplyTokens) {
-                    if (token?.symbol &&
-                        !token.is_suspicious &&
-                        !token.is_scam &&
-                        token?.is_core) {
-                        supplying_exposure.push({
-                            symbol: token.symbol,
-                            chain: token.chain,
-                            amount: token.amount * token.price,
-                        });
-                    }
-                }
-            }
-        }
-        return { borrowing_exposure, supplying_exposure, wallet_exposure };
-    }
-    async allowance(pool, signer) {
-        if (!(0, ethers_1.isAddress)(pool))
-            return;
-        const wallet = (await signer.getAddress());
-        return await (0, core_1.allowance)(signer, { target: pool, wallet, wait: true });
-    }
-    async approve(pool, signer, inputParams) {
-        if (!(0, ethers_1.isAddress)(pool))
-            return;
-        const wallet = (await signer.getAddress());
-        return await (0, core_1.approve)(signer, {
-            target: pool,
-            wallet,
-            wait: true,
-            amount: inputParams.amount,
-        });
-    }
-    async deposit(pool, signer, inputParams, solana) {
-        if (solana_1.Solana.utils.isSolanaAddress(pool)) {
-            const vaultState = await this.solanaService.getVaultStateReadOnly(pool, solana_1.Solana.constants.vaultIdl);
-            const solanaTx = await this.solanaService.handleDeposit(pool, solana_1.Solana.constants.vaultIdl, signer, Number(inputParams.amount), vaultState.vaultState.depositMint, solana?.sendTransaction);
-            return solanaTx;
-        }
-        if (typeof signer === 'string')
-            return;
-        const wallet = (await signer.getAddress());
-        return await (0, user_actions_1.vaultDeposit)(signer, {
-            amount: inputParams.amount,
-            wallet,
-            target: pool,
-            wait: true,
+    async getVaultTvl({ vault, chainId, historical, }) {
+        if (!this.authorized)
+            throw new Error('Not authorized.');
+        if (!vault)
+            throw new Error('Pool input parameter is undefined.');
+        if (!(0, ethers_1.isAddress)(vault))
+            throw new Error(`Pool input parameter is not an address: ${String(vault)}`);
+        const rpcUrl = chainId
+            ? this.providers?.[chainId]
+            : this.activeNetwork.rpcUrl;
+        return await (0, getters_1.getVaultTvl)({
+            vault,
+            options: {
+                rpcUrl: rpcUrl,
+                solanaService: this.solanaService,
+                env: this.monitoring?.env,
+                augustKey: this.keys?.august,
+                subgraphKey: this.keys?.graph,
+                headers: this.headers,
+            },
+            historical: historical,
         });
     }
-    async requestWithdrawal(pool, signer) {
-        const wallet = (await signer.getAddress());
-        return await (0, user_actions_1.vaultRequestRedeem)(signer, { target: pool, wallet, wait: true });
-    }
-    async withdraw(pool, signer, inputParams, solana) {
-        if (solana_1.Solana.utils.isSolanaAddress(pool)) {
-            const vaultState = await this.solanaService.getVaultStateReadOnly(pool, solana_1.Solana.constants.vaultIdl);
-            const solanaTx = await this.solanaService.handleRedeem(pool, solana_1.Solana.constants.vaultIdl, signer, Number(inputParams.amount), vaultState.vaultState.depositMint, solana?.sendTransaction);
-            return solanaTx;
+    async getVaultBorrowerHealthFactor(chainId) {
+        if (chainId) {
+            const health_factors = await (0, getters_1.getHealthFactorOfBorrowersByVault)({
+                options: {
+                    rpcUrl: this.providers?.[chainId] || this.activeNetwork.rpcUrl,
+                    env: this.monitoring?.env,
+                    augustKey: this.keys?.august,
+                },
+            });
+            return health_factors;
         }
-        if (typeof signer === 'string')
-            return;
-        if (!(inputParams.day &&
-            inputParams.month &&
-            inputParams.year &&
-            inputParams.receiverIndex))
-            return;
-        const wallet = (await signer.getAddress());
-        return await (0, user_actions_1.vaultRedeem)(signer, {
-            wallet,
-            pool,
-            ...inputParams,
-            wait: true,
-        });
+        const health_factors = await Promise.all(Object.values(this.providers).map((rpcUrl) => {
+            return (0, getters_1.getHealthFactorOfBorrowersByVault)({
+                options: {
+                    rpcUrl: chainId
+                        ? this.providers?.[chainId]
+                        : rpcUrl || this.activeNetwork.rpcUrl,
+                    solanaService: this.solanaService,
+                    env: this.monitoring?.env,
+                    augustKey: this.keys?.august,
+                    subgraphKey: this.keys?.graph,
+                    headers: this.headers,
+                },
+            });
+        }));
+        return health_factors.flat();
     }
 }
 exports.AugustVaults = AugustVaults;
+exports.default = AugustVaults;
 //# sourceMappingURL=main.js.map