@augustdigital/sdk 4.1.0-alpha → 4.1.0

package/lib/modules/vaults/getters.js

@@ -32,6 +32,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVault = getVault;
 exports.getVaultLoans = getVaultLoans;
@@ -41,18 +44,22 @@ exports.getVaultRedemptionHistory = getVaultRedemptionHistory;
 exports.getVaultPositions = getVaultPositions;
 exports.getVaultApy = getVaultApy;
 exports.getRewardsStakingPositions = getRewardsStakingPositions;
+exports.getVaultTvl = getVaultTvl;
+exports.getVaultBorrowerHealthFactor = getVaultBorrowerHealthFactor;
+exports.getHealthFactorOfBorrowersByVault = getHealthFactorOfBorrowersByVault;
 const abis_1 = require("../../abis");
 const core_1 = require("../../core");
 const ethers_1 = require("ethers");
-const utils_1 = require("./utils");
 const subgraph_1 = require("../../services/subgraph");
-const constants_1 = require("./constants");
 const debank_1 = require("../../services/debank");
 const solana_1 = require("../../adapters/solana");
 const EVM = __importStar(require("../../adapters/evm"));
+const TokenizedVaultV2_1 = require("../../abis/TokenizedVaultV2");
+const TokenizedVaultV2Receipt_1 = require("../../abis/TokenizedVaultV2Receipt");
+const ethereum_block_by_date_1 = __importDefault(require("ethereum-block-by-date"));
 async function getVault({ vault, loans = false, allocations = false, options, }) {
     let returnedVault;
-    const vaultVersion = (0, utils_1.getVaultVersion)(vault);
+    const vaultVersion = (0, core_1.getVaultVersion)(vault);
     try {
         const tokenizedVault = (await (0, core_1.fetchTokenizedVaults)(vault))?.[0];
         switch (vaultVersion) {
@@ -73,10 +80,10 @@ async function getVault({ vault, loans = false, allocations = false, options, })
         }
     }
     catch (err) {
-        console.error(`#getVault::${vault}::${vaultVersion}:`, err);
-        throw new Error(`#getVault::${vault}::${err?.message}`);
+        core_1.Logger.log.error('getVault', err, { vault, vaultVersion });
+        throw new Error(`#getVault::${vault}::${vaultVersion}: ${err?.message}`);
     }
-    if (!(0, constants_1.isBadVault)(vault)) {
+    if (!(0, core_1.isBadVault)(vault)) {
         if (loans) {
             try {
                 returnedVault = {
@@ -85,7 +92,9 @@ async function getVault({ vault, loans = false, allocations = false, options, })
                 };
             }
             catch (e) {
-                console.error(`getVault::${returnedVault.receipt.symbol}:`, e?.message);
+                core_1.Logger.log.error('getVault:loans', e, {
+                    symbol: returnedVault.receipt.symbol,
+                });
             }
         }
         if (allocations) {
@@ -97,7 +106,9 @@ async function getVault({ vault, loans = false, allocations = false, options, })
                 };
             }
             catch (e) {
-                console.error(`getVault::${returnedVault.receipt.symbol}:`, e?.message);
+                core_1.Logger.log.error('getVault:allocations', e, {
+                    symbol: returnedVault.receipt.symbol,
+                });
                 throw new Error('Failure fetching debank res');
             }
         }
@@ -106,7 +117,7 @@ async function getVault({ vault, loans = false, allocations = false, options, })
 }
 async function getVaultLoans(vault, options) {
     const vaultAddress = typeof vault === 'string' ? vault : vault.address;
-    const vaultVersion = (0, utils_1.getVaultVersion)(vaultAddress);
+    const vaultVersion = (0, core_1.getVaultVersion)(vaultAddress);
     if (vaultVersion !== 'evm-0')
         return [];
     try {
@@ -140,7 +151,7 @@ async function getVaultLoans(vault, options) {
             const loanFeeRate = await (0, core_1.getLoanOracleFeeRate)(provider, 'LOAN.REPAY.INTERESTS', l.address, chainId);
             const loanApr = Number(l.apr || 0) / 100;
             const loanAprAfterFees = loanApr * (1 - loanFeeRate / 100);
-            const isIdleCapital = constants_1.IDLE_CAPITAL_BORROWER_ADDRESS.includes(borrower);
+            const isIdleCapital = core_1.IDLE_CAPITAL_BORROWER_ADDRESS.includes(borrower);
             const newLoanObj = {
                 vault: vaultAddress,
                 address: l.address,
@@ -167,7 +178,7 @@ async function getVaultLoans(vault, options) {
         return newLoans;
     }
     catch (e) {
-        console.error('#getVaultLoans:', e);
+        core_1.Logger.log.error('getVaultLoans', e, { vault });
         throw new Error(`#getVaultLoans::${vault}:${e?.message}`);
     }
 }
@@ -194,7 +205,7 @@ async function getVaultAllocations(vault, options) {
     let uniqueBorrowers;
     const tokenizedVault = (await (0, core_1.fetchTokenizedVaults)(vault, options?.headers))?.[0];
     try {
-        const vaultVersion = (0, utils_1.getVaultVersion)(vault);
+        const vaultVersion = (0, core_1.getVaultVersion)(vault);
         if (vaultVersion === 'evm-0') {
             const loans = await getVaultLoans(vault, options);
             uniqueBorrowers = [...new Set(loans.map((l) => l.borrower))];
@@ -204,17 +215,17 @@ async function getVaultAllocations(vault, options) {
         }
     }
     catch (e) {
-        console.error('#getVaultAllocations::borrowers:', e);
+        core_1.Logger.log.error('getVaultAllocations:borrowers', e);
     }
-    if (vault.toLowerCase() === constants_1.VAULT_AgoraAUSD.toLowerCase()) {
-        const debankRes = await (0, debank_1.fetchDebankResponse)(constants_1.SUBACCOUNT_CALEB);
+    if (vault.toLowerCase() === core_1.VAULT_AgoraAUSD.toLowerCase()) {
+        const debankRes = await (0, debank_1.fetchDebankResponse)(core_1.SUBACCOUNT_CALEB);
         if (debankRes === false) {
             debankErr = true;
         }
-        (0, debank_1.parseVaultLevelDebank)(debankRes, protocolExposure, tokenExposure, constants_1.SUBACCOUNT_CALEB, exposurePerCategory, netValue);
+        (0, debank_1.parseVaultLevelDebank)(debankRes, protocolExposure, tokenExposure, core_1.SUBACCOUNT_CALEB, exposurePerCategory, netValue);
         unfilteredTokens = debankRes?.subaccount?.tokens;
         const debankPerLoan = (0, debank_1.parseLoanLevelDebank)(debankRes);
-        defiPerBorrower[constants_1.SUBACCOUNT_CALEB] = debankPerLoan;
+        defiPerBorrower[core_1.SUBACCOUNT_CALEB] = debankPerLoan;
     }
     else {
         for (const borrower of uniqueBorrowers) {
@@ -229,7 +240,7 @@ async function getVaultAllocations(vault, options) {
                 defiPerBorrower[borrower] = debankPerLoan;
             }
             catch (e) {
-                console.error('#getVaultAllocations::debank:', e);
+                core_1.Logger.log.error('getVaultAllocations:debank', e, { borrower });
             }
             try {
                 const cefiResponse = await (0, core_1.fetchAugustWithKey)(options.augustKey, core_1.WEBSERVER_ENDPOINTS.subaccount.cefi(borrower), { headers: options?.headers });
@@ -288,64 +299,110 @@ async function getVaultAvailableRedemptions({ vault, wallet, options, }) {
         if (!tokenizedVault) {
             return { availableRedemptions: [], pendingRedemptions: [] };
         }
-        const poolContract = (0, core_1.createContract)({
+        const version = (0, core_1.getVaultVersion)(vault);
+        let abi;
+        let decimals;
+        switch (version) {
+            case 'evm-2': {
+                abi = TokenizedVaultV2_1.ABI_TOKENIZED_VAULT_V2;
+                decimals = await (0, core_1.getDecimals)(provider, await (0, core_1.getReceiptTokenAddress)(provider, vault));
+                break;
+            }
+            default: {
+                abi = abis_1.ABI_LENDING_POOL_V2;
+                decimals = await (0, core_1.getDecimals)(provider, vault);
+                break;
+            }
+        }
+        const vaultContract = (0, core_1.createContract)({
             address: vault,
-            abi: abis_1.ABI_LENDING_POOL_V2,
+            abi: abi,
             provider,
         });
         const { withdrawalRequesteds, withdrawalProcesseds } = await (0, subgraph_1.getSubgraphAllWithdrawals)(vault, provider);
-        const decimals = await (0, core_1.getDecimals)(provider, vault);
         const availableRedemptions = [];
         const pendingRedemptions = [];
         for (const ev of withdrawalRequesteds) {
             if (!ev || typeof ev !== 'object') {
-                console.warn('#getVaultAvailableRedemptions: Skipping invalid event:', ev);
+                core_1.Logger.log.warn('getVaultAvailableRedemptions', `Skipping invalid event: ${ev}`);
                 continue;
             }
             if (!ev.year || !ev.month || !ev.day || !ev.receiverAddr) {
-                console.warn('#getVaultAvailableRedemptions: Skipping event with missing required properties:', ev);
+                core_1.Logger.log.warn('getVaultAvailableRedemptions', `Skipping event with missing required properties: ${ev}`);
                 continue;
             }
             const fullDate = new Date(Number(ev.year), Number(ev.month) - 1, Number(ev.day));
             const foundRedemptionAgainstClaim = withdrawalProcesseds.find((h) => new Date(h.processedOn).toDateString() === fullDate.toDateString() &&
                 h.receiverAddr === ev.receiverAddr);
-            if (wallet) {
+            if (wallet && (0, ethers_1.isAddress)(wallet)) {
                 if (ev?.receiverAddr?.toLowerCase() === wallet.toLowerCase()) {
                     const alreadyRedeemed = availableRedemptions.find((red) => BigInt(red.day.raw) === BigInt(ev.day) &&
                         BigInt(red.month.raw) === BigInt(ev.month) &&
                         BigInt(red.year.raw) === BigInt(ev.year));
                     if (!(foundRedemptionAgainstClaim && alreadyRedeemed)) {
                         try {
-                            const trueClaimableAmount = await poolContract?.getClaimableAmountByReceiver?.(BigInt(ev.year), BigInt(ev.month), BigInt(ev.day), (0, ethers_1.getAddress)(wallet));
-                            if (trueClaimableAmount > BigInt(0)) {
-                                availableRedemptions.push({
-                                    id: ev.transactionHash_ || ev.id,
-                                    hash: ev.transactionHash_ || ev.id,
-                                    timestamp: Number(ev.timestamp_),
-                                    receiver: ev.receiverAddr,
-                                    day: (0, core_1.toNormalizedBn)(ev.day, 0),
-                                    month: (0, core_1.toNormalizedBn)(ev.month, 0),
-                                    year: (0, core_1.toNormalizedBn)(ev.year, 0),
-                                    amount: (0, core_1.toNormalizedBn)(trueClaimableAmount, decimals),
-                                    date: fullDate,
-                                    vault,
-                                });
+                            switch (version) {
+                                case 'evm-2': {
+                                    availableRedemptions.push({
+                                        id: ev.transactionHash_ || ev.id,
+                                        hash: ev.transactionHash_ || ev.id,
+                                        timestamp: Number(ev.timestamp_),
+                                        receiver: ev.receiverAddr,
+                                        day: (0, core_1.toNormalizedBn)(ev.day, 0),
+                                        month: (0, core_1.toNormalizedBn)(ev.month, 0),
+                                        year: (0, core_1.toNormalizedBn)(ev.year, 0),
+                                        amount: (0, core_1.toNormalizedBn)(ev.shares, decimals),
+                                        date: fullDate,
+                                        vault,
+                                    });
+                                    pendingRedemptions.push({
+                                        id: ev.transactionHash_ || ev.id,
+                                        hash: ev.transactionHash_ || ev.id,
+                                        timestamp: Number(ev.timestamp_),
+                                        receiver: ev.receiverAddr,
+                                        day: (0, core_1.toNormalizedBn)(ev.day, 0),
+                                        month: (0, core_1.toNormalizedBn)(ev.month, 0),
+                                        year: (0, core_1.toNormalizedBn)(ev.year, 0),
+                                        amount: (0, core_1.toNormalizedBn)(ev.shares || BigInt(0), decimals),
+                                        date: fullDate,
+                                        vault,
+                                    });
+                                    break;
+                                }
+                                default: {
+                                    const trueClaimableAmount = await vaultContract?.getClaimableAmountByReceiver?.(BigInt(ev.year), BigInt(ev.month), BigInt(ev.day), (0, ethers_1.getAddress)(wallet));
+                                    if (trueClaimableAmount > BigInt(0)) {
+                                        availableRedemptions.push({
+                                            id: ev.transactionHash_ || ev.id,
+                                            hash: ev.transactionHash_ || ev.id,
+                                            timestamp: Number(ev.timestamp_),
+                                            receiver: ev.receiverAddr,
+                                            day: (0, core_1.toNormalizedBn)(ev.day, 0),
+                                            month: (0, core_1.toNormalizedBn)(ev.month, 0),
+                                            year: (0, core_1.toNormalizedBn)(ev.year, 0),
+                                            amount: (0, core_1.toNormalizedBn)(trueClaimableAmount, decimals),
+                                            date: fullDate,
+                                            vault,
+                                        });
+                                    }
+                                    pendingRedemptions.push({
+                                        id: ev.transactionHash_ || ev.id,
+                                        hash: ev.transactionHash_ || ev.id,
+                                        timestamp: Number(ev.timestamp_),
+                                        receiver: ev.receiverAddr,
+                                        day: (0, core_1.toNormalizedBn)(ev.day, 0),
+                                        month: (0, core_1.toNormalizedBn)(ev.month, 0),
+                                        year: (0, core_1.toNormalizedBn)(ev.year, 0),
+                                        amount: (0, core_1.toNormalizedBn)(trueClaimableAmount || BigInt(0), decimals),
+                                        date: fullDate,
+                                        vault,
+                                    });
+                                    break;
+                                }
                             }
-                            pendingRedemptions.push({
-                                id: ev.transactionHash_ || ev.id,
-                                hash: ev.transactionHash_ || ev.id,
-                                timestamp: Number(ev.timestamp_),
-                                receiver: ev.receiverAddr,
-                                day: (0, core_1.toNormalizedBn)(ev.day, 0),
-                                month: (0, core_1.toNormalizedBn)(ev.month, 0),
-                                year: (0, core_1.toNormalizedBn)(ev.year, 0),
-                                amount: (0, core_1.toNormalizedBn)(trueClaimableAmount || BigInt(0), decimals),
-                                date: fullDate,
-                                vault,
-                            });
                         }
                         catch (contractError) {
-                            console.error('#getVaultAvailableRedemptions: Contract call failed:', contractError);
+                            core_1.Logger.log.error('getVaultAvailableRedemptions', `Contract call failed: ${contractError}`);
                             pendingRedemptions.push({
                                 id: ev.transactionHash_ || ev.id,
                                 hash: ev.transactionHash_ || ev.id,
@@ -382,7 +439,7 @@ async function getVaultAvailableRedemptions({ vault, wallet, options, }) {
         return { availableRedemptions, pendingRedemptions };
     }
     catch (e) {
-        console.error('#getVaultAvailableRedemptions:', e);
+        core_1.Logger.log.error('getVaultAvailableRedemptions', e, { vault, wallet });
         return { availableRedemptions: [], pendingRedemptions: [] };
     }
 }
@@ -442,12 +499,11 @@ async function getVaultRedemptionHistory({ vault, wallet, options, }) {
                 });
             }
         });
-        if (options.env === 'DEV')
-            console.log('#getVaultRedemptionHistory:', redemptions.slice(0, 1));
+        core_1.Logger.log.info('getVaultRedemptionHistory', redemptions.slice(0, 1));
         return redemptions;
     }
     catch (e) {
-        console.error('#getVaultRedemptionHistory:', e);
+        core_1.Logger.log.error('getVaultRedemptionHistory', e, { vault, wallet });
         return [];
     }
 }
@@ -485,14 +541,45 @@ async function getVaultPositions({ vault, wallet, solanaWallet, options, }) {
                     };
                 }
                 const provider = (0, core_1.createProvider)(options.rpcUrl);
-                const decimals = await (0, core_1.getDecimals)(provider, vault);
-                const poolContract = (0, core_1.createContract)({
+                let decimals;
+                let abi;
+                const version = (0, core_1.getVaultVersion)(vault);
+                switch (version) {
+                    case 'evm-2': {
+                        decimals = await (0, core_1.getDecimals)(provider, await (0, core_1.getReceiptTokenAddress)(provider, vault));
+                        abi = TokenizedVaultV2_1.ABI_TOKENIZED_VAULT_V2;
+                        break;
+                    }
+                    default: {
+                        decimals = await (0, core_1.getDecimals)(provider, vault);
+                        abi = abis_1.ABI_LENDING_POOL_V2;
+                        break;
+                    }
+                }
+                const vaultContract = (0, core_1.createContract)({
                     provider,
-                    abi: abis_1.ABI_LENDING_POOL_V2,
+                    abi: abi,
                     address: v.address,
                 });
-                const bal = await poolContract.balanceOf(wallet);
-                const balance = (0, core_1.toNormalizedBn)(bal || 0, decimals);
+                let bal = BigInt(0);
+                if (wallet && (0, ethers_1.isAddress)(wallet)) {
+                    switch (version) {
+                        case 'evm-2': {
+                            const receiptContract = (0, core_1.createContract)({
+                                provider,
+                                abi: TokenizedVaultV2Receipt_1.ABI_TOKENIZED_VAULT_V2_RECEIPT,
+                                address: await (0, core_1.getReceiptTokenAddress)(provider, vault),
+                            });
+                            bal = await receiptContract.balanceOf(wallet);
+                            break;
+                        }
+                        default: {
+                            bal = await vaultContract.balanceOf(wallet);
+                            break;
+                        }
+                    }
+                }
+                const balance = (0, core_1.toNormalizedBn)(bal, decimals);
                 const { availableRedemptions, pendingRedemptions } = await getVaultAvailableRedemptions({
                     vault: v.address,
                     wallet,
@@ -509,7 +596,7 @@ async function getVaultPositions({ vault, wallet, solanaWallet, options, }) {
                 };
             }
             catch (vaultError) {
-                console.error(`#getVaultPositions: Error processing vault ${v.address}:`, vaultError);
+                core_1.Logger.log.error(`getVaultPositions`, `Error processing vault ${v.address}: ${vaultError}`);
                 return {
                     vault,
                     status: 'PENDING',
@@ -523,17 +610,51 @@ async function getVaultPositions({ vault, wallet, solanaWallet, options, }) {
         return promises.flat();
     }
     catch (e) {
-        console.error('#getVaultPositions:', e);
+        core_1.Logger.log.error('getVaultPositions', e, { vault, wallet, solanaWallet });
         throw new Error(`#getVaultPositions::${vault}:${e?.message}`);
     }
 }
-async function getVaultApy({ vault, options, }) {
+async function getVaultApy({ vault, options, historical, }) {
     try {
-        const tokenizedVault = (await (0, core_1.fetchTokenizedVaults)(vault, options?.headers))?.[0];
-        return tokenizedVault?.reported_apy?.apy || 0;
+        if (!vault)
+            throw new Error('Vault input parameter is undefined.');
+        if (!historical) {
+            const tokenizedVault = (await (0, core_1.fetchTokenizedVaults)(vault, options?.headers))?.[0];
+            return [
+                {
+                    value: tokenizedVault?.reported_apy?.apy || 0,
+                    timestamp: new Date().toISOString(),
+                },
+            ];
+        }
+        else {
+            function paramBuilder(params) {
+                const urlParams = new URLSearchParams();
+                if (!params)
+                    return '';
+                if (params.daysAgo)
+                    urlParams.append('days_ago', params.daysAgo.toString());
+                return urlParams.toString();
+            }
+            const historicalApy = await (0, core_1.fetchAugustPublic)(`${core_1.WEBSERVER_ENDPOINTS.public.tokenizedVault.historicalApy(vault)}${paramBuilder(historical)}`, {
+                headers: !!options?.headers
+                    ? options?.headers
+                    : undefined,
+            });
+            if (!historicalApy.ok)
+                throw new Error('Failed to fetch historical apy.');
+            const historicalApyData = (await historicalApy.json());
+            return historicalApyData.data.values.map((val, index) => {
+                const respectiveDate = historicalApyData.data.labels[index];
+                return {
+                    timestamp: new Date(respectiveDate).toISOString(),
+                    value: val,
+                };
+            });
+        }
     }
     catch (e) {
-        console.error('#getVaultApy:', e);
+        core_1.Logger.log.error('getVaultApy', e, { vault });
         throw new Error(`#getVaultApy::${vault}:${e?.message}`);
     }
 }
@@ -548,14 +669,14 @@ async function getRewardsStakingPositions({ rpcUrl, wallet, coinGeckoKey, }) {
         const provider = (0, core_1.createProvider)(rpcUrl);
         const chainId = await (0, core_1.getChainId)(provider);
         if (chainId !== REWARDS_CHAIN) {
-            console.warn('#getStakingPositions: no rewards distributor on chain_id', chainId);
+            core_1.Logger.log.warn('getStakingPositions:unsupported_chain', chainId);
             return [];
         }
         if (wallet && !(0, ethers_1.isAddress)(wallet)) {
-            console.warn('#getStakingPositions: wallet passed is not a valid address', wallet);
+            core_1.Logger.log.warn('getStakingPositions:invalid_wallet', wallet);
             return [];
         }
-        const rewardDistributorAddresses = (0, utils_1.REWARD_DISTRIBUTOR_ADDRESS)(chainId);
+        const rewardDistributorAddresses = (0, core_1.REWARD_DISTRIBUTOR_ADDRESS)(chainId);
         const positions = await Promise.all(rewardDistributorAddresses.map(async (contract, i) => {
             const rewardContract = (0, core_1.createContract)({
                 address: contract,
@@ -571,7 +692,7 @@ async function getRewardsStakingPositions({ rpcUrl, wallet, coinGeckoKey, }) {
                 provider: provider,
                 abi: abis_1.ABI_ERC20,
             });
-            const [decimals, symbol, name, totalSupply] = await Promise.all(stakingTokenCalls.map((staking) => stakingTokenContract[staking]()));
+            const [decimals, symbol, name] = await Promise.all(stakingTokenCalls.map((staking) => stakingTokenContract[staking]()));
             let balance;
             let earned;
             if (wallet) {
@@ -630,7 +751,182 @@ async function getRewardsStakingPositions({ rpcUrl, wallet, coinGeckoKey, }) {
         return positions;
     }
     catch (e) {
-        console.error('#getStakingPositions:', e);
+        core_1.Logger.log.error('getStakingPositions', e, { wallet });
+        return [];
     }
 }
+async function getVaultTvl({ vault, options, historical, }) {
+    try {
+        if (!vault)
+            throw new Error('Vault input parameter is undefined.');
+        const _vaultExists = (await (0, core_1.fetchTokenizedVaults)(vault))?.[0];
+        if (!_vaultExists) {
+            throw new Error(`Vault ${vault} not found in backend`);
+        }
+        if (!historical) {
+            const version = (0, core_1.getVaultVersion)(vault);
+            const provider = (0, core_1.createProvider)(options.rpcUrl);
+            switch (version) {
+                case 'evm-2': {
+                    const receiptTokenAddress = await (0, core_1.getReceiptTokenAddress)(provider, vault);
+                    const receiptTokenDecimals = await (0, core_1.getDecimals)(provider, receiptTokenAddress);
+                    const receiptTokenContract = (0, core_1.createContract)({
+                        address: receiptTokenAddress,
+                        abi: TokenizedVaultV2Receipt_1.ABI_TOKENIZED_VAULT_V2_RECEIPT,
+                        provider,
+                    });
+                    const totalSupply = await receiptTokenContract.getTotalSupply();
+                    return [
+                        {
+                            value: (0, core_1.toNormalizedBn)(totalSupply, receiptTokenDecimals),
+                            timestamp: new Date().toISOString(),
+                        },
+                    ];
+                }
+                case 'sol-0': {
+                    return [
+                        {
+                            value: (0, core_1.toNormalizedBn)(0),
+                            timestamp: new Date().toISOString(),
+                        },
+                    ];
+                }
+                default: {
+                    const vaultContract = (0, core_1.createContract)({
+                        address: vault,
+                        abi: TokenizedVaultV2_1.ABI_TOKENIZED_VAULT_V2,
+                        provider,
+                    });
+                    const decimals = await (0, core_1.getDecimals)(provider, vault);
+                    const totalSupply = await vaultContract.totalSupply();
+                    return [
+                        {
+                            value: (0, core_1.toNormalizedBn)(totalSupply, decimals),
+                            timestamp: new Date().toISOString(),
+                        },
+                    ];
+                }
+            }
+        }
+        else {
+            if (typeof historical !== 'undefined' && !historical.order)
+                historical.order = 'desc';
+            if (typeof historical !== 'undefined' && !historical.interval)
+                historical.interval = 'days';
+            const provider = (0, core_1.createProvider)(options.rpcUrl);
+            const version = (0, core_1.getVaultVersion)(vault);
+            const vaultContract = (0, core_1.createContract)({
+                address: vault,
+                abi: version === 'evm-2' ? TokenizedVaultV2_1.ABI_TOKENIZED_VAULT_V2 : abis_1.ABI_LENDING_POOL_V2,
+                provider,
+            });
+            let minAbi = [];
+            let functionName = '';
+            let vaultDecimals = 0;
+            switch (version) {
+                case 'evm-2': {
+                    minAbi = ['function getTotalAssets() view returns (uint256)'];
+                    functionName = 'getTotalAssets';
+                    const receiptTokenAddress = await (0, core_1.getReceiptTokenAddress)(provider, vault);
+                    vaultDecimals = await (0, core_1.getDecimals)(provider, receiptTokenAddress);
+                    break;
+                }
+                default: {
+                    minAbi = ['function totalAssets() view returns (uint256)'];
+                    functionName = 'totalAssets';
+                    vaultDecimals = await (0, core_1.getDecimals)(provider, vault);
+                    break;
+                }
+            }
+            const finalizedBlock = await provider.getBlock('finalized');
+            const finalizedTimestamp = finalizedBlock
+                ? finalizedBlock.timestamp * 1000
+                : Date.now() * 60 * 1000;
+            const daysAgo = historical.daysAgo * 24 * 60 * 60 * 1000;
+            const dater = new ethereum_block_by_date_1.default(provider);
+            const startDate = historical.daysAgo
+                ? new Date(finalizedTimestamp - daysAgo)
+                : new Date(finalizedTimestamp);
+            const blocks = await dater.getEvery(historical.interval, startDate.toUTCString(), new Date(finalizedTimestamp).toUTCString());
+            const orderedBlocks = historical.order === 'desc' ? (0, core_1.orderObjArrByDate)(blocks) : blocks;
+            const totalAssetsHistorical = await (0, core_1.promiseSettle)(orderedBlocks?.map(async ({ block, date }) => {
+                const totalAssetsAtBlock = await provider.call({
+                    to: vaultContract,
+                    data: new ethers_1.Interface(minAbi).encodeFunctionData(functionName, []),
+                    blockTag: block,
+                });
+                if (totalAssetsAtBlock === '0x')
+                    return {
+                        timestamp: (0, core_1.dateToUnix)(new Date(date)),
+                        value: (0, core_1.toNormalizedBn)(0, 0),
+                    };
+                const readableTotalAssetsAtBlock = new ethers_1.Interface(minAbi).decodeFunctionResult(functionName, totalAssetsAtBlock);
+                return {
+                    timestamp: (0, core_1.dateToUnix)(new Date(date)),
+                    value: (0, core_1.toNormalizedBn)(readableTotalAssetsAtBlock?.[0], vaultDecimals),
+                };
+            }));
+            core_1.Logger.log.info('getVaultTvl:historical', totalAssetsHistorical.length);
+            return totalAssetsHistorical;
+        }
+    }
+    catch (e) {
+        core_1.Logger.log.error('getVaultTvl', e, { vault });
+        throw new Error(`Failed to fetch TVL for ${vault}: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+async function getVaultBorrowerHealthFactor({ vault, options, }) {
+    const provider = (0, core_1.createProvider)(options.rpcUrl);
+    const loans = await getVaultLoans(vault, options);
+    const activeLoans = (await Promise.all(loans.map(async (l) => {
+        const loanContract = (0, core_1.createContract)({
+            provider,
+            address: l.address,
+            abi: abis_1.ABI_LOAN,
+        });
+        const loanState = await loanContract.loanState();
+        if ((0, core_1.loanStateToReadable)(loanState) !== 'ACTIVE')
+            return;
+        return l.address;
+    }))).filter((l) => l !== undefined);
+    const formattedLoansArray = await Promise.all(activeLoans.map(async (l) => {
+        const loanContract = (0, core_1.createContract)({
+            provider,
+            address: l,
+            abi: abis_1.ABI_LOAN,
+        });
+        return {
+            borrower: await loanContract.borrower(),
+            loan: l,
+        };
+    }));
+    const uniqueBorrowers = [
+        ...new Set(formattedLoansArray.map((l) => l.borrower)),
+    ];
+    let borrowerResponses = {};
+    for (const b of uniqueBorrowers) {
+        const response = await (0, core_1.fetchAugustWithKey)(options.augustKey, core_1.WEBSERVER_ENDPOINTS.subaccount.health_factor(b));
+        if (response.status === 200) {
+            borrowerResponses[b] = await response.json();
+        }
+    }
+    formattedLoansArray?.map((loan) => {
+        loan.health_factor = borrowerResponses[loan.borrower];
+    });
+    return formattedLoansArray;
+}
+async function getHealthFactorOfBorrowersByVault({ options, }) {
+    const vaults = await (0, core_1.fetchTokenizedVaults)();
+    const healthFactors = await Promise.all(vaults.map(async (v) => {
+        return getVaultBorrowerHealthFactor({
+            vault: v.address,
+            options,
+        });
+    }));
+    const healthFactorsByPool = {};
+    vaults.map((pool, index) => {
+        healthFactorsByPool[pool.address] = healthFactors[index];
+    });
+    return healthFactorsByPool;
+}
 //# sourceMappingURL=getters.js.map