@augustdigital/sdk 4.0.6-alpha → 4.0.6-beta

package/lib/modules/vaults/getters.js

@@ -0,0 +1,900 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        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;
+exports.getVaultAllocations = getVaultAllocations;
+exports.getVaultAvailableRedemptions = getVaultAvailableRedemptions;
+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 subgraph_1 = require("../../services/subgraph");
+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, core_1.getVaultVersion)(vault);
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVaults)(vault))?.[0];
+        switch (vaultVersion) {
+            case 'sol-0': {
+                return await solana_1.Solana.getters.getSolanaVault(tokenizedVault, options);
+            }
+            case 'evm-2': {
+                returnedVault = await EVM.getEvmVaultV2(tokenizedVault, options);
+                break;
+            }
+            default: {
+                returnedVault = await EVM.getEvmVaultV1(tokenizedVault, options);
+                break;
+            }
+        }
+        if (returnedVault === null) {
+            return null;
+        }
+    }
+    catch (err) {
+        core_1.Logger.log.error('getVault', err, { vault, vaultVersion });
+        throw new Error(`#getVault::${vault}::${vaultVersion}: ${err?.message}`);
+    }
+    if (!(0, core_1.isBadVault)(vault)) {
+        if (loans) {
+            try {
+                returnedVault = {
+                    ...returnedVault,
+                    loans: await getVaultLoans(returnedVault, options),
+                };
+            }
+            catch (e) {
+                core_1.Logger.log.error('getVault:loans', e, {
+                    symbol: returnedVault.receipt.symbol,
+                });
+            }
+        }
+        if (allocations) {
+            try {
+                const vaultAllocations = await getVaultAllocations(vault, options);
+                returnedVault = {
+                    ...returnedVault,
+                    allocations: vaultAllocations,
+                };
+            }
+            catch (e) {
+                core_1.Logger.log.error('getVault:allocations', e, {
+                    symbol: returnedVault.receipt.symbol,
+                });
+                throw new Error('Failure fetching debank res');
+            }
+        }
+    }
+    return returnedVault;
+}
+async function getVaultLoans(vault, options) {
+    const vaultAddress = typeof vault === 'string' ? vault : vault.address;
+    const vaultVersion = (0, core_1.getVaultVersion)(vaultAddress);
+    if (vaultVersion !== 'evm-0')
+        return [];
+    try {
+        let poolTotalSupply;
+        let poolDecimals;
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVaults)(vaultAddress, options?.headers))?.[0];
+        const chainId = options?.chainId || tokenizedVault?.chain;
+        const provider = (0, core_1.createProvider)(options.rpcUrl);
+        const tokenizedVaultLoans = await (0, core_1.fetchTokenizedVaultLoans)(vaultAddress, chainId);
+        if (typeof vault === 'string') {
+            const poolContract = (0, core_1.createContract)({
+                provider,
+                address: vaultAddress,
+                abi: abis_1.ABI_LENDING_POOL_V2,
+            });
+            [poolTotalSupply, poolDecimals] = await Promise.all([
+                poolContract.totalSupply(),
+                (0, core_1.getDecimals)(provider, vaultAddress),
+            ]);
+            poolTotalSupply = BigInt(poolTotalSupply).toString();
+            poolDecimals = Number(poolDecimals);
+        }
+        else {
+            poolTotalSupply = vault.totalSupply.raw;
+            poolDecimals = vault.decimals;
+        }
+        const newLoans = (await Promise.all((Array.isArray(tokenizedVaultLoans) ? tokenizedVaultLoans : [])?.map(async (l) => {
+            const borrower = l.borrower;
+            const allocation = l.principal_amount /
+                Number((0, ethers_1.formatUnits)(poolTotalSupply, poolDecimals));
+            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 = core_1.IDLE_CAPITAL_BORROWER_ADDRESS.includes(borrower);
+            const newLoanObj = {
+                vault: vaultAddress,
+                address: l.address,
+                lender: l.lender,
+                borrower: l.borrower,
+                state: l.state,
+                totalRepaid: l.total_repaid,
+                principalToken: l.principal_token,
+                principalAmount: l.principal_amount,
+                interestAmount: l.interest_amount,
+                upcomingPayment: {
+                    amount: l.upcoming_payment.amount,
+                    dueDate: l.upcoming_payment.due_date,
+                },
+                apr: loanAprAfterFees,
+                initialPrincipalAmount: l.initial_principal_amount,
+                deployedDate: l.deployed_date,
+                isIdleCapital,
+                paymentInterval: l.payment_interval,
+                allocation,
+            };
+            return newLoanObj;
+        }))).filter((l) => l !== undefined);
+        return newLoans;
+    }
+    catch (e) {
+        core_1.Logger.log.error('getVaultLoans', e, { vault });
+        throw new Error(`#getVaultLoans::${vault}:${e?.message}`);
+    }
+}
+async function getVaultAllocations(vault, options) {
+    let protocolExposure = [];
+    let tokenExposure = [];
+    let cefiExposure = [];
+    let cefiBorrowerResponses = {};
+    let otcPositions = {};
+    let defiPerBorrower = {};
+    let exposurePerCategory = {
+        supplying: [],
+        borrowing: [],
+        wallet: [],
+        walletBalance: 0,
+        cefiBalance: 0,
+        defiBalance: 0,
+        lending: [],
+        loanBalance: 0,
+    };
+    let netValue = { value: 0 };
+    let debankErr = false;
+    let unfilteredTokens = [];
+    let uniqueBorrowers;
+    const tokenizedVault = (await (0, core_1.fetchTokenizedVaults)(vault, options?.headers))?.[0];
+    try {
+        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))];
+        }
+        else {
+            uniqueBorrowers = tokenizedVault.subaccounts.map((s) => s.address);
+        }
+    }
+    catch (e) {
+        core_1.Logger.log.error('getVaultAllocations:borrowers', e);
+    }
+    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, core_1.SUBACCOUNT_CALEB, exposurePerCategory, netValue);
+        unfilteredTokens = debankRes?.subaccount?.tokens;
+        const debankPerLoan = (0, debank_1.parseLoanLevelDebank)(debankRes);
+        defiPerBorrower[core_1.SUBACCOUNT_CALEB] = debankPerLoan;
+    }
+    else {
+        for (const borrower of uniqueBorrowers) {
+            try {
+                const debankRes = await (0, debank_1.fetchDebankResponse)(borrower);
+                if (debankRes === false) {
+                    debankErr = true;
+                }
+                (0, debank_1.parseVaultLevelDebank)(debankRes, protocolExposure, tokenExposure, borrower, exposurePerCategory, netValue);
+                unfilteredTokens = debankRes?.subaccount?.tokens;
+                const debankPerLoan = (0, debank_1.parseLoanLevelDebank)(debankRes);
+                defiPerBorrower[borrower] = debankPerLoan;
+            }
+            catch (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 });
+                if (cefiResponse.status !== 200) {
+                    console.error('#getVaultAllocations::cefi:', cefiResponse.status, cefiResponse.statusText);
+                }
+                if (cefiResponse.status === 200) {
+                    const cefiRes = (await cefiResponse.json());
+                    cefiBorrowerResponses[borrower] = cefiRes;
+                    cefiExposure = cefiRes;
+                }
+            }
+            catch (e) {
+                console.error('#getVaultAllocations::cefi:', e);
+            }
+            try {
+                const otcResponse = await (0, core_1.fetchAugustWithKey)(options.augustKey, core_1.WEBSERVER_ENDPOINTS.subaccount.otc_positions(borrower), { headers: options?.headers });
+                if (otcResponse.status !== 200) {
+                    console.error('#getVaultAllocations::otc:', otcResponse.status, otcResponse.statusText);
+                }
+                if (otcResponse.status === 200) {
+                    const otcRes = (await otcResponse.json());
+                    otcPositions[borrower] = otcRes;
+                }
+            }
+            catch (e) {
+                console.error('#getVaultAllocations::otc:', e);
+            }
+        }
+    }
+    const walletBalance = exposurePerCategory.wallet.reduce((sum, item) => sum + item.amount, 0);
+    const defiBalance = protocolExposure.reduce((sum, item) => sum + item.netUsdValue, 0);
+    const cefiBalance = cefiExposure.reduce((sum, item) => sum + item.value, 0);
+    exposurePerCategory.walletBalance = walletBalance;
+    exposurePerCategory.defiBalance = defiBalance;
+    exposurePerCategory.cefiBalance = cefiBalance;
+    netValue.value += cefiBalance;
+    if (debankErr) {
+        throw Error('failure to fetch debank response');
+    }
+    return {
+        defi: protocolExposure,
+        cefi: cefiExposure,
+        otc: otcPositions,
+        tokens: tokenExposure,
+        defiPerBorrower,
+        exposurePerCategory,
+        netValue: netValue.value,
+        unfilteredTokens: unfilteredTokens,
+    };
+}
+async function getVaultAvailableRedemptions({ vault, wallet, options, }) {
+    try {
+        const provider = (0, core_1.createProvider)(options.rpcUrl);
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVaults)(vault, options?.headers))?.[0];
+        if (!tokenizedVault) {
+            return { availableRedemptions: [], pendingRedemptions: [] };
+        }
+        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: abi,
+            provider,
+        });
+        const { withdrawalRequesteds, withdrawalProcesseds } = await (0, subgraph_1.getSubgraphAllWithdrawals)(vault, provider);
+        const availableRedemptions = [];
+        const pendingRedemptions = [];
+        for (const ev of withdrawalRequesteds) {
+            if (!ev || typeof ev !== 'object') {
+                core_1.Logger.log.warn('getVaultAvailableRedemptions', `Skipping invalid event: ${ev}`);
+                continue;
+            }
+            if (!ev.year || !ev.month || !ev.day || !ev.receiverAddr) {
+                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 && (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 {
+                            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;
+                                }
+                            }
+                        }
+                        catch (contractError) {
+                            core_1.Logger.log.error('getVaultAvailableRedemptions', `Contract call failed: ${contractError}`);
+                            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)(BigInt(0), decimals),
+                                date: fullDate,
+                                vault,
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                if (!!foundRedemptionAgainstClaim) {
+                    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.assets || BigInt(0), decimals),
+                        date: fullDate,
+                        vault,
+                    });
+                }
+            }
+        }
+        return { availableRedemptions, pendingRedemptions };
+    }
+    catch (e) {
+        core_1.Logger.log.error('getVaultAvailableRedemptions', e, { vault, wallet });
+        return { availableRedemptions: [], pendingRedemptions: [] };
+    }
+}
+async function getVaultRedemptionHistory({ vault, wallet, options, }) {
+    try {
+        const provider = (0, core_1.createProvider)(options.rpcUrl);
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVaults)(vault, options?.headers))?.[0];
+        if (!tokenizedVault) {
+            return [];
+        }
+        const chainId = tokenizedVault.chain;
+        const poolContract = (0, core_1.createContract)({
+            address: vault,
+            abi: abis_1.ABI_LENDING_POOL_V2,
+            provider,
+        });
+        let logPromises = [];
+        const currentBlock = await provider.getBlockNumber();
+        let startingBlock = currentBlock - (0, core_1.determineBlockSkipInternal)(chainId);
+        let endBlock = currentBlock;
+        const cutoffBlock = currentBlock - (0, core_1.determineBlockCutoff)(chainId);
+        while (endBlock >= cutoffBlock) {
+            const logBloomsPromises = poolContract.queryFilter('WithdrawalProcessed', BigInt(startingBlock), BigInt(endBlock));
+            logPromises.push(logBloomsPromises);
+            startingBlock -= (0, core_1.determineBlockSkipInternal)(chainId);
+            endBlock -= (0, core_1.determineBlockSkipInternal)(chainId);
+        }
+        const logs = (await Promise.all(logPromises.flat())).flat();
+        const iface = new ethers_1.ethers.Interface([
+            'event WithdrawalProcessed (uint256 assetsAmount, uint256 processedOn, address receiverAddr, uint256 requestedOn)',
+        ]);
+        const events = logs.map((log) => iface.parseLog(log));
+        const decimals = await (0, core_1.getDecimals)(provider, vault);
+        const redemptions = [];
+        events?.forEach((ev) => {
+            if (!ev?.args)
+                return;
+            const [assetsAmount, processedOn, receiverAddr, requestedOn] = ev.args;
+            if (wallet) {
+                if (String(receiverAddr)?.toLowerCase() === wallet.toLowerCase()) {
+                    redemptions.push({
+                        receiver: receiverAddr,
+                        amount: (0, core_1.toNormalizedBn)(assetsAmount, decimals),
+                        processed: new Date(Number(processedOn) * 1000),
+                        requested: new Date(Number(requestedOn) * 1000),
+                        vault,
+                    });
+                }
+            }
+            else {
+                redemptions.push({
+                    receiver: receiverAddr,
+                    amount: (0, core_1.toNormalizedBn)(assetsAmount, decimals),
+                    processed: new Date(Number(processedOn) * 1000),
+                    requested: new Date(Number(requestedOn) * 1000),
+                    vault,
+                });
+            }
+        });
+        core_1.Logger.log.info('getVaultRedemptionHistory', redemptions.slice(0, 1));
+        return redemptions;
+    }
+    catch (e) {
+        core_1.Logger.log.error('getVaultRedemptionHistory', e, { vault, wallet });
+        return [];
+    }
+}
+async function getVaultPositions({ vault, wallet, solanaWallet, options, }) {
+    try {
+        const tokenizedVaults = await (0, core_1.fetchTokenizedVaults)(vault ? vault : undefined, options?.headers);
+        if (!tokenizedVaults || tokenizedVaults.length === 0) {
+            return [];
+        }
+        function renderStatus(_redemptions, _balance) {
+            if (_redemptions?.length)
+                return 'REDEEM';
+            if (BigInt(_balance.raw) > BigInt(0))
+                return 'STAKED';
+            return 'PENDING';
+        }
+        const promises = await Promise.all(tokenizedVaults.map(async (v) => {
+            try {
+                if (solana_1.Solana.utils.isSolanaAddress(v.address)) {
+                    let balance = (0, core_1.toNormalizedBn)(0);
+                    if (solana_1.Solana.utils.isSolanaAddress(solanaWallet)) {
+                        const vaultStateRes = await options.solanaService.getVaultState(String(v.address), solana_1.Solana.constants.vaultIdl);
+                        if (vaultStateRes &&
+                            vaultStateRes?.vaultState?.shareMint) {
+                            balance = (0, core_1.toNormalizedBn)(await options.solanaService.fetchUserShareBalance(solanaWallet, vaultStateRes?.vaultState?.shareMint));
+                        }
+                    }
+                    return {
+                        vault,
+                        status: renderStatus([], balance),
+                        availableRedemptions: [],
+                        pendingRedemptions: [],
+                        redeemable: balance,
+                        walletBalance: balance,
+                    };
+                }
+                const provider = (0, core_1.createProvider)(options.rpcUrl);
+                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: abi,
+                    address: v.address,
+                });
+                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,
+                    options,
+                });
+                const aggregateAvailableRedemptions = availableRedemptions?.reduce((acc, curr) => acc + BigInt(curr.amount.raw), BigInt(0));
+                return {
+                    vault,
+                    status: renderStatus(availableRedemptions, balance),
+                    availableRedemptions,
+                    pendingRedemptions,
+                    redeemable: (0, core_1.toNormalizedBn)(aggregateAvailableRedemptions, decimals),
+                    walletBalance: balance,
+                };
+            }
+            catch (vaultError) {
+                console.error(`#getVaultPositions: Error processing vault ${v.address}:`, vaultError);
+                return {
+                    vault,
+                    status: 'PENDING',
+                    availableRedemptions: [],
+                    pendingRedemptions: [],
+                    redeemable: (0, core_1.toNormalizedBn)(0),
+                    walletBalance: (0, core_1.toNormalizedBn)(0),
+                };
+            }
+        }));
+        return promises.flat();
+    }
+    catch (e) {
+        core_1.Logger.log.error('getVaultPositions', e, { vault, wallet, solanaWallet });
+        throw new Error(`#getVaultPositions::${vault}:${e?.message}`);
+    }
+}
+async function getVaultApy({ vault, options, historical, }) {
+    try {
+        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) {
+        core_1.Logger.log.error('getVaultApy', e, { vault });
+        throw new Error(`#getVaultApy::${vault}:${e?.message}`);
+    }
+}
+async function getRewardsStakingPositions({ rpcUrl, wallet, coinGeckoKey, }) {
+    const REWARDS_CHAIN = 43114;
+    const REWARDS_SYMBOL = 'AVAX';
+    const REWARDS_DECIMALS = 18;
+    const REWARDS_NAME = 'Avalanche';
+    const APR_MULTIPLIER = 31536000;
+    const UP_AUSD_SYMBOL = 'upAUSD';
+    try {
+        const provider = (0, core_1.createProvider)(rpcUrl);
+        const chainId = await (0, core_1.getChainId)(provider);
+        if (chainId !== REWARDS_CHAIN) {
+            core_1.Logger.log.warn('getStakingPositions:unsupported_chain', chainId);
+            return [];
+        }
+        if (wallet && !(0, ethers_1.isAddress)(wallet)) {
+            core_1.Logger.log.warn('getStakingPositions:invalid_wallet', wallet);
+            return [];
+        }
+        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,
+                provider: provider,
+                abi: abis_1.ABI_REWARD_DISTRIBUTOR,
+            });
+            const totalStaked = await rewardContract.totalStaked();
+            const rewardsPerSecond = await rewardContract.rewardsPerSecond();
+            const stakingTokenCalls = ['decimals', 'symbol', 'name', 'totalSupply'];
+            const stakingTokenAddress = (await rewardContract.stakingToken());
+            const stakingTokenContract = (0, core_1.createContract)({
+                address: stakingTokenAddress,
+                provider: provider,
+                abi: abis_1.ABI_ERC20,
+            });
+            const [decimals, symbol, name] = await Promise.all(stakingTokenCalls.map((staking) => stakingTokenContract[staking]()));
+            let balance;
+            let earned;
+            if (wallet) {
+                const formattedWallet = (0, ethers_1.getAddress)(wallet);
+                balance = await rewardContract.balanceOf(formattedWallet);
+                earned = await rewardContract.earned(formattedWallet);
+            }
+            const rewardTokenPriceInUsd = await (0, core_1.fetchTokenPrice)(REWARDS_SYMBOL, null, coinGeckoKey);
+            const normalizedRewardTokenPrice = (0, core_1.toNormalizedBn)(rewardTokenPriceInUsd);
+            const normalizedTotalStakedInPool = (0, core_1.toNormalizedBn)(totalStaked, decimals);
+            const normalizedRedeemable = (0, core_1.toNormalizedBn)(earned, REWARDS_DECIMALS);
+            const normalizedRewardsPerSecond = (0, core_1.toNormalizedBn)(rewardsPerSecond, REWARDS_DECIMALS);
+            const normalizedTotalStakedBalance = (0, core_1.toNormalizedBn)(balance, decimals);
+            const rewardTokenPriceToMultiply = symbol === UP_AUSD_SYMBOL
+                ? Number(normalizedRewardTokenPrice?.normalized)
+                : 1;
+            const STAKED_APR = ((Number(normalizedRewardsPerSecond?.normalized) *
+                APR_MULTIPLIER *
+                rewardTokenPriceToMultiply) /
+                (Number(normalizedTotalStakedInPool?.normalized) * Number(1))) *
+                100;
+            const MAX_APR = ((Number(normalizedRewardsPerSecond?.normalized) *
+                APR_MULTIPLIER *
+                rewardTokenPriceToMultiply) /
+                (Number(normalizedTotalStakedInPool?.normalized) * Number(1))) *
+                100;
+            const activePosition = {
+                id: String(i),
+                rewardToken: {
+                    decimals: REWARDS_DECIMALS,
+                    symbol: REWARDS_SYMBOL,
+                    address: ethers_1.ZeroAddress,
+                    chain: REWARDS_CHAIN,
+                    redeemable: normalizedRedeemable,
+                    usd: normalizedRewardTokenPrice,
+                    name: REWARDS_NAME,
+                },
+                stakingToken: {
+                    decimals: Number(decimals),
+                    symbol: symbol,
+                    address: stakingTokenAddress,
+                    chain: REWARDS_CHAIN,
+                    totalStaked: normalizedTotalStakedBalance,
+                    usd: normalizedRewardTokenPrice,
+                    totalSupply: normalizedTotalStakedInPool,
+                    name: name,
+                },
+                rewardDistributor: contract,
+                rewardPerSecond: (0, core_1.toNormalizedBn)(rewardsPerSecond),
+                apy: STAKED_APR,
+                maxApy: MAX_APR,
+                chainId: REWARDS_CHAIN,
+            };
+            return activePosition;
+        }));
+        return positions;
+    }
+    catch (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 vaultRes = await getVault({
+                vault,
+                options,
+                loans: false,
+                allocations: false,
+            });
+            const returnObj = [
+                { value: vaultRes.totalSupply, timestamp: new Date().toISOString() },
+            ];
+            core_1.Logger.log.info('getVaultTvl:current', returnObj);
+            return returnObj;
+        }
+        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