@augustdigital/sdk 4.25.0-alpha.0 → 4.25.1

package/lib/modules/vaults/getters.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVault = getVault;
 exports.getVaultLoans = getVaultLoans;
+exports.getVaultSubaccountLoans = getVaultSubaccountLoans;
 exports.getVaultAllocations = getVaultAllocations;
 exports.getVaultAvailableRedemptions = getVaultAvailableRedemptions;
 exports.getVaultRedemptionHistory = getVaultRedemptionHistory;
@@ -57,18 +58,23 @@ exports.getVaultHistoricalTimeseries = getVaultHistoricalTimeseries;
 exports.getVaultAnnualizedApy = getVaultAnnualizedApy;
 exports.getVaultSummary = getVaultSummary;
 exports.getVaultWithdrawals = getVaultWithdrawals;
+exports.getVaultPendingRedemptions = getVaultPendingRedemptions;
 exports.getPreviewRedemption = getPreviewRedemption;
 exports.getWithdrawalRequestsWithStatus = getWithdrawalRequestsWithStatus;
 const abis_1 = require("../../abis");
 const types_1 = require("../../types");
 const core_1 = require("../../core");
 const ethers_1 = require("ethers");
+const utils_1 = require("./utils");
 const subgraph_1 = require("../../services/subgraph");
 const vaults_1 = require("../../services/subgraph/vaults");
 const debank_1 = require("../../services/debank");
-const utils_1 = require("../../adapters/solana/utils");
+const utils_2 = require("../../adapters/solana/utils");
 const SolanaGetters = __importStar(require("../../adapters/solana/getters"));
 const SolanaConstants = __importStar(require("../../adapters/solana/constants"));
+const StellarGetters = __importStar(require("../../adapters/stellar/getters"));
+const utils_3 = require("../../adapters/stellar/utils");
+const constants_1 = require("../../adapters/stellar/constants");
 const EVM = __importStar(require("../../adapters/evm"));
 const TokenizedVaultV2_1 = require("../../abis/TokenizedVaultV2");
 const TokenizedVaultV2Receipt_1 = require("../../abis/TokenizedVaultV2Receipt");
@@ -76,6 +82,8 @@ const ethereum_block_by_date_1 = __importDefault(require("ethereum-block-by-date
 const octavfi_1 = require("../../services/octavfi");
 const date_utils_1 = require("./utils/date-utils");
 const call_data_decoder_1 = require("./utils/call-data-decoder");
+const deposits_1 = require("../../services/layerzero/deposits");
+const redeems_1 = require("../../services/layerzero/redeems");
 async function getVault({ vault, loans = false, allocations = false, options, loadSubaccounts, loadSnapshots, }) {
     let returnedVault;
     try {
@@ -84,7 +92,12 @@ async function getVault({ vault, loans = false, allocations = false, options, lo
         const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
         switch (vaultVersion) {
             case 'sol-0': {
-                return await SolanaGetters.getSolanaVault(tokenizedVault, options);
+                returnedVault = await SolanaGetters.getSolanaVault(tokenizedVault, options);
+                break;
+            }
+            case 'stellar-0': {
+                returnedVault = await StellarGetters.getStellarVault(tokenizedVault, options);
+                break;
             }
             case 'evm-2': {
                 returnedVault = await EVM.getEvmVaultV2(tokenizedVault, options);
@@ -103,7 +116,13 @@ async function getVault({ vault, loans = false, allocations = false, options, lo
         core_1.Logger.log.error('getVault', err, { vault });
         throw new Error(`#getVault::${vault}: ${err?.message}`);
     }
-    if (!(0, core_1.isBadVault)(vault)) {
+    const isEvmVault = returnedVault.version !== 'sol-0' &&
+        returnedVault.version !== 'stellar-0' &&
+        returnedVault.version !== 'sui-0';
+    if (!isEvmVault && (loans || allocations)) {
+        core_1.Logger.log.warn('getVault', 'Loans/allocations enrichment is not supported for non-EVM vaults — skipping', { vault, version: returnedVault.version });
+    }
+    if (isEvmVault && !(0, core_1.isBadVault)(vault)) {
         if (loans) {
             try {
                 returnedVault = {
@@ -203,6 +222,74 @@ async function getVaultLoans(vault, options) {
         throw new Error(`#getVaultLoans::${vault}:${e?.message}`);
     }
 }
+async function getVaultSubaccountLoans(vault, options) {
+    const vaultAddress = typeof vault === 'string' ? vault : vault.address;
+    const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vaultAddress))?.[0];
+    const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+    if (vaultVersion !== 'evm-0')
+        return [];
+    try {
+        let poolTotalSupply;
+        let poolDecimals;
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vaultAddress, options?.headers))?.[0];
+        const chainId = options?.chainId || tokenizedVault?.chain;
+        const provider = (0, core_1.createProvider)(options.rpcUrl);
+        const tokenizedVaultLoans = await (0, core_1.fetchTokenizedVaultSubaccountLoans)(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('getVaultSubaccountLoans', e, { vault });
+        throw new Error(`#getVaultSubaccountLoans::${vault}:${e?.message}`);
+    }
+}
 async function getVaultAllocations(vault, options) {
     const protocolExposure = [];
     const tokenExposure = [];
@@ -324,7 +411,10 @@ async function getVaultAllocations(vault, options) {
             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);
+                    core_1.Logger.log.error('getVaultAllocations:cefi', cefiResponse.statusText, {
+                        borrower,
+                        status: cefiResponse.status,
+                    });
                 }
                 if (cefiResponse.status === 200) {
                     const cefiRes = (await cefiResponse.json());
@@ -332,12 +422,15 @@ async function getVaultAllocations(vault, options) {
                 }
             }
             catch (e) {
-                console.error('#getVaultAllocations::cefi:', e);
+                core_1.Logger.log.error('getVaultAllocations:cefi', e, { borrower });
             }
             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);
+                    core_1.Logger.log.error('getVaultAllocations:otc', otcResponse.statusText, {
+                        borrower,
+                        status: otcResponse.status,
+                    });
                 }
                 if (otcResponse.status === 200) {
                     const otcRes = (await otcResponse.json());
@@ -345,7 +438,7 @@ async function getVaultAllocations(vault, options) {
                 }
             }
             catch (e) {
-                console.error('#getVaultAllocations::otc:', e);
+                core_1.Logger.log.error('getVaultAllocations:otc', e, { borrower });
             }
         }
     }
@@ -372,6 +465,17 @@ async function getVaultAllocations(vault, options) {
 }
 async function getVaultAvailableRedemptions({ vault, wallet, options, }) {
     try {
+        if ((0, utils_3.isStellarAddress)(vault)) {
+            core_1.Logger.log.warn('getVaultAvailableRedemptions', `Available redemptions is not yet supported for Stellar vaults: ${vault}`);
+            return {
+                availableRedemptions: [],
+                pendingRedemptions: [],
+                ...(options.verbose && {
+                    processedWithdrawals: [],
+                    requestedWithdrawals: [],
+                }),
+            };
+        }
         const provider = (0, core_1.createProvider)(options.rpcUrl);
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, options?.headers, false, false))?.[0];
         if (!tokenizedVault) {
@@ -623,9 +727,14 @@ async function getVaultAvailableRedemptions({ vault, wallet, options, }) {
 }
 async function getVaultRedemptionHistory({ vault, wallet, options, }) {
     try {
+        if ((0, utils_3.isStellarAddress)(vault)) {
+            core_1.Logger.log.warn('getVaultRedemptionHistory', `Redemption history is not yet supported for Stellar vaults: ${vault}`);
+            return [];
+        }
         const provider = (0, core_1.createProvider)(options.rpcUrl);
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, options?.headers, false, false))?.[0];
         if (!tokenizedVault) {
+            core_1.Logger.log.warn('getVaultRedemptionHistory', `Vault not found in backend: ${vault}`);
             return [];
         }
         const chainId = tokenizedVault.chain;
@@ -736,7 +845,7 @@ async function getVaultRedemptionHistory({ vault, wallet, options, }) {
         return [];
     }
 }
-async function getVaultPositions({ vault, wallet, solanaWallet, options, }) {
+async function getVaultPositions({ vault, wallet, solanaWallet, stellarWallet, options, }) {
     try {
         const tokenizedVaults = await (0, core_1.fetchTokenizedVault)(vault ? vault : undefined, options?.headers, false, false);
         if (!tokenizedVaults || tokenizedVaults.length === 0) {
@@ -751,10 +860,10 @@ async function getVaultPositions({ vault, wallet, solanaWallet, options, }) {
         }
         const promises = await Promise.all(tokenizedVaults.map(async (v) => {
             try {
-                if (utils_1.SolanaUtils.isSolanaAddress(v.address)) {
+                if (utils_2.SolanaUtils.isSolanaAddress(v.address)) {
                     let balance = (0, core_1.toNormalizedBn)(0);
-                    if (utils_1.SolanaUtils.isSolanaAddress(solanaWallet)) {
-                        const vaultProgramId = utils_1.SolanaUtils.resolveProgramId(String(v.address), v.solana_vault_metadata);
+                    if (utils_2.SolanaUtils.isSolanaAddress(solanaWallet)) {
+                        const vaultProgramId = utils_2.SolanaUtils.resolveProgramId(String(v.address), v.solana_vault_metadata);
                         const vaultStateRes = await options.solanaService.getVaultState(vaultProgramId, SolanaConstants.vaultIdl, v.solana_vault_metadata?.vault_state_pda ?? undefined);
                         if (vaultStateRes &&
                             vaultStateRes?.vaultState?.shareMint) {
@@ -770,6 +879,30 @@ async function getVaultPositions({ vault, wallet, solanaWallet, options, }) {
                         walletBalance: balance,
                     };
                 }
+                if ((0, utils_3.isStellarAddress)(v.address)) {
+                    let balance = (0, core_1.toNormalizedBn)(0);
+                    if (stellarWallet && (0, utils_3.isStellarAddress)(stellarWallet)) {
+                        const stellarNetwork = v.stellar_vault_metadata?.network_name ?? 'mainnet';
+                        const position = await StellarGetters.getStellarUserPosition(v.address, stellarWallet, stellarNetwork);
+                        if (position) {
+                            balance = (0, core_1.toNormalizedBn)(BigInt(position.shares), position.decimals);
+                        }
+                        else {
+                            core_1.Logger.log.warn('getVaultPositions', 'Stellar position query failed — showing zero balance', { vault: v.address, wallet: stellarWallet });
+                        }
+                    }
+                    else if (stellarWallet) {
+                        core_1.Logger.log.warn('getVaultPositions', 'Invalid stellarWallet address format', { vault: v.address, stellarWallet });
+                    }
+                    return {
+                        vault: v.address,
+                        status: renderStatus([], balance),
+                        availableRedemptions: [],
+                        pendingRedemptions: [],
+                        redeemable: (0, core_1.toNormalizedBn)(0),
+                        walletBalance: balance,
+                    };
+                }
                 const provider = (0, core_1.createProvider)(options.rpcUrl);
                 let decimals;
                 const version = (0, core_1.getVaultVersionV2)(v);
@@ -827,7 +960,12 @@ async function getVaultPositions({ vault, wallet, solanaWallet, options, }) {
         return promises.flat();
     }
     catch (e) {
-        core_1.Logger.log.error('getVaultPositions', e, { vault, wallet, solanaWallet });
+        core_1.Logger.log.error('getVaultPositions', e, {
+            vault,
+            wallet,
+            solanaWallet,
+            stellarWallet,
+        });
         throw new Error(`#getVaultPositions::${vault}:${e?.message}`);
     }
 }
@@ -990,6 +1128,24 @@ async function getVaultTvl({ vault, options, historical, }) {
         }
         if (!historical) {
             const version = (0, core_1.getVaultVersionV2)(_vaultExists);
+            if (version === 'sol-0') {
+                return [
+                    {
+                        value: (0, core_1.toNormalizedBn)(0),
+                        timestamp: new Date().toISOString(),
+                    },
+                ];
+            }
+            if (version === 'stellar-0') {
+                const stellarDecimals = _vaultExists?.stellar_vault_metadata?.deposit_token_decimals ??
+                    constants_1.STELLAR_FALLBACK_DECIMALS;
+                return [
+                    {
+                        value: (0, utils_1.backendTvlToNormalizedBn)(_vaultExists?.latest_reported_tvl, stellarDecimals),
+                        timestamp: new Date().toISOString(),
+                    },
+                ];
+            }
             const provider = (0, core_1.createProvider)(options.rpcUrl);
             switch (version) {
                 case 'evm-2': {
@@ -1008,14 +1164,6 @@ async function getVaultTvl({ vault, options, historical, }) {
                         },
                     ];
                 }
-                case 'sol-0': {
-                    return [
-                        {
-                            value: (0, core_1.toNormalizedBn)(0),
-                            timestamp: new Date().toISOString(),
-                        },
-                    ];
-                }
                 default: {
                     const vaultContract = (0, core_1.createContract)({
                         address: vault,
@@ -1034,12 +1182,16 @@ async function getVaultTvl({ vault, options, historical, }) {
             }
         }
         else {
+            const version = (0, core_1.getVaultVersionV2)(_vaultExists);
+            if (version === 'stellar-0' || version === 'sol-0') {
+                core_1.Logger.log.warn('getVaultTvl:historical', 'Historical TVL not supported for non-EVM vaults', { vault, version });
+                return [];
+            }
             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.getVaultVersionV2)(_vaultExists);
             const vaultContract = (0, core_1.createContract)({
                 address: vault,
                 abi: version === 'evm-2' ? TokenizedVaultV2_1.ABI_TOKENIZED_VAULT_V2 : abis_1.ABI_LENDING_POOL_V2,
@@ -1254,7 +1406,8 @@ async function getYieldLastRealizedOn({ vault, options, }) {
                 assetsUpdatedOn = await contract.assetsUpdatedOn();
                 break;
             }
-            case 'sol-0': {
+            case 'sol-0':
+            case 'stellar-0': {
                 return 0;
             }
             default: {
@@ -1275,6 +1428,7 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
             throw new Error('Vault input parameter is undefined.');
         if (!wallet)
             throw new Error('Wallet input parameter is undefined.');
+        (0, utils_3.assertNotStellar)(vault, 'Lifetime PnL');
         if (!(0, ethers_1.isAddress)(vault))
             throw new Error(`Vault input parameter is not an address: ${String(vault)}`);
         if (!(0, ethers_1.isAddress)(wallet))
@@ -1294,6 +1448,30 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
         if (!tokenizedVault) {
             throw new Error(`Vault ${vault} not found`);
         }
+        const lzVaultKey = (0, deposits_1.isLayerZeroVault)(vault);
+        let lzDeposits = [];
+        let lzRedeems = [];
+        if (lzVaultKey) {
+            const lzPromises = [
+                (0, deposits_1.queryLayerZeroDeposits)(lzVaultKey, wallet)
+                    .then((d) => {
+                    lzDeposits = d;
+                })
+                    .catch((e) => {
+                    core_1.Logger.log.warn('getVaultUserLifetimePnl:lzDeposits', `Failed to fetch LZ deposits for ${lzVaultKey}: ${e}`);
+                }),
+            ];
+            if (lzVaultKey === 'earnAUSD') {
+                lzPromises.push((0, redeems_1.queryLayerZeroRedeems)(wallet)
+                    .then((r) => {
+                    lzRedeems = r;
+                })
+                    .catch((e) => {
+                    core_1.Logger.log.warn('getVaultUserLifetimePnl:lzRedeems', `Failed to fetch LZ redeems for ${lzVaultKey}: ${e}`);
+                }));
+            }
+            await Promise.all(lzPromises);
+        }
         const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
         const currentPosition = positions.find((pos) => pos.vault?.toLowerCase() === vault.toLowerCase());
         const underlyingSymbolPromise = (async () => {
@@ -1350,9 +1528,22 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
                 totalWithdrawalsInAssets += amount;
             }
         }
+        if (lzVaultKey && lzDeposits.length > 0) {
+            for (const lzDeposit of lzDeposits) {
+                const assetKey = 'lz-default';
+                const amount = BigInt(lzDeposit.assetAmt);
+                const current = depositsByAsset.get(assetKey) ?? BigInt(0);
+                depositsByAsset.set(assetKey, current + amount);
+            }
+        }
+        if (lzVaultKey && lzRedeems.length > 0) {
+            for (const lzRedeem of lzRedeems) {
+                totalWithdrawalsInShares += BigInt(lzRedeem.shareAmt);
+            }
+        }
         const assetDecimals = new Map();
         await Promise.all(Array.from(depositsByAsset.keys()).map(async (assetAddress) => {
-            if (assetAddress === 'default') {
+            if (assetAddress === 'default' || assetAddress === 'lz-default') {
                 assetDecimals.set(assetAddress, decimals);
             }
             else {
@@ -1368,7 +1559,7 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
         const assetPrices = new Map();
         if (tokenizedVault.chain) {
             await Promise.all(Array.from(depositsByAsset.keys()).map(async (assetAddress) => {
-                if (assetAddress === 'default') {
+                if (assetAddress === 'default' || assetAddress === 'lz-default') {
                     assetPrices.set(assetAddress, 0);
                 }
                 else {
@@ -1410,6 +1601,71 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
             else {
                 currentShares = await vaultContract.balanceOf(wallet);
             }
+            if (lzVaultKey) {
+                const remoteChains = [];
+                if (tokenizedVault.receipt_token_integrations?.length) {
+                    for (const rti of tokenizedVault.receipt_token_integrations) {
+                        if (rti.chain !== tokenizedVault.chain &&
+                            rti.address &&
+                            rti.chain) {
+                            remoteChains.push({
+                                chain: rti.chain,
+                                address: rti.address,
+                            });
+                        }
+                    }
+                }
+                else {
+                    const lzVaultConfig = deposits_1.LAYERZERO_VAULTS[lzVaultKey];
+                    if (lzVaultConfig.spokeChains) {
+                        for (const [chainIdStr, address] of Object.entries(lzVaultConfig.spokeChains)) {
+                            const chainId = Number(chainIdStr);
+                            if (chainId !== tokenizedVault.chain) {
+                                remoteChains.push({
+                                    chain: chainId,
+                                    address: address,
+                                });
+                            }
+                        }
+                    }
+                }
+                if (remoteChains.length > 0) {
+                    const remoteBalances = await Promise.all(remoteChains.map(async ({ chain, address }) => {
+                        try {
+                            const rpcUrls = (0, core_1.getFallbackRpcUrls)(chain);
+                            if (!rpcUrls.length) {
+                                core_1.Logger.log.warn('getVaultUserLifetimePnl:lzRemoteBalance', `No RPC URL for chain ${chain}, skipping balance check`);
+                                return BigInt(0);
+                            }
+                            const remoteProvider = (0, core_1.createProvider)(rpcUrls[0]);
+                            const remoteTokenContract = (0, core_1.createContract)({
+                                provider: remoteProvider,
+                                address,
+                                abi: abis_1.ABI_ERC20,
+                            });
+                            const [rawBalance, remoteDecimals] = await Promise.all([
+                                remoteTokenContract.balanceOf(wallet),
+                                remoteTokenContract.decimals(),
+                            ]);
+                            const remDec = Number(remoteDecimals) || decimals;
+                            if (remDec > decimals) {
+                                return rawBalance / BigInt(10 ** (remDec - decimals));
+                            }
+                            else if (remDec < decimals) {
+                                return rawBalance * BigInt(10 ** (decimals - remDec));
+                            }
+                            return rawBalance;
+                        }
+                        catch (e) {
+                            core_1.Logger.log.warn('getVaultUserLifetimePnl:lzRemoteBalance', `Failed to fetch balance on chain ${chain}: ${e}`);
+                            return BigInt(0);
+                        }
+                    }));
+                    for (const bal of remoteBalances) {
+                        currentShares += bal;
+                    }
+                }
+            }
             if (version === 'evm-2') {
                 sharePriceRaw = await vaultContract.getSharePrice();
             }
@@ -1450,7 +1706,7 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
         }
         let totalDepositedUsd = 0;
         for (const [assetAddress, normalizedAmount] of totalDepositedRaw) {
-            const assetPrice = assetAddress === 'default'
+            const assetPrice = assetAddress === 'default' || assetAddress === 'lz-default'
                 ? effectiveTokenPrice
                 : assetPrices.get(assetAddress) || effectiveTokenPrice;
             totalDepositedUsd += Number(normalizedAmount.normalized) * assetPrice;
@@ -1496,6 +1752,7 @@ async function getVaultPnl({ vault, options, }) {
     try {
         if (!vault)
             throw new Error('Vault input parameter is undefined.');
+        (0, utils_3.assertNotStellar)(vault, 'Vault PnL');
         if (!(0, ethers_1.isAddress)(vault))
             throw new Error(`Vault input parameter is not an address: ${String(vault)}`);
         const vaultData = await getVault({
@@ -1617,6 +1874,7 @@ async function getVaultSummary({ vault, options, }) {
         if (!vault) {
             throw new Error('Vault address parameter is undefined.');
         }
+        (0, utils_3.assertNotStellar)(vault, 'Vault summary');
         if (!(0, ethers_1.isAddress)(vault)) {
             throw new Error(`Vault parameter is not an address: ${String(vault)}`);
         }
@@ -1641,6 +1899,7 @@ async function getVaultWithdrawals({ vault, chain, options, }) {
         if (!vault) {
             throw new Error('Vault address parameter is undefined.');
         }
+        (0, utils_3.assertNotStellar)(vault, 'Vault withdrawals');
         if (!(0, ethers_1.isAddress)(vault)) {
             throw new Error(`Vault parameter is not an address: ${String(vault)}`);
         }
@@ -1663,10 +1922,78 @@ async function getVaultWithdrawals({ vault, chain, options, }) {
         throw new Error(`#getVaultWithdrawals::${vault}::${chain}:${errorMessage}`);
     }
 }
+async function getVaultPendingRedemptions({ vault, pastDays, futureDays, options, }) {
+    try {
+        if (!vault)
+            throw new Error('Vault address parameter is undefined.');
+        if (!(0, ethers_1.isAddress)(vault))
+            throw new Error(`Vault parameter is not an address: ${String(vault)}`);
+        if (pastDays !== undefined && (pastDays < 1 || pastDays > 30))
+            throw new Error('pastDays must be between 1 and 30');
+        if (futureDays !== undefined && (futureDays < 1 || futureDays > 30))
+            throw new Error('futureDays must be between 1 and 30');
+        const params = new URLSearchParams();
+        if (pastDays !== undefined)
+            params.set('past_days', pastDays.toString());
+        if (futureDays !== undefined)
+            params.set('future_days', futureDays.toString());
+        const qs = params.toString();
+        const endpoint = `${core_1.WEBSERVER_ENDPOINTS.public.vaults.pendingRedemptions(vault)}${qs ? `?${qs}` : ''}`;
+        const response = await (0, core_1.fetchAugustPublic)(endpoint, {
+            headers: options?.headers,
+            server: 'public',
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch pending redemptions: ${response.statusText}`);
+        }
+        const raw = await response.json();
+        return {
+            vault: {
+                address: raw.vault.address,
+                chainId: raw.vault.chain_id,
+                name: raw.vault.name,
+                symbol: raw.vault.symbol,
+            },
+            asset: {
+                address: raw.asset.address,
+                symbol: raw.asset.symbol,
+                decimals: raw.asset.decimals,
+            },
+            liquidity: {
+                available: raw.liquidity.available,
+            },
+            summary: {
+                totalPending: raw.summary.total_pending,
+                pendingCount: raw.summary.pending_count,
+                pendingToLiquidityRatio: raw.summary.pending_to_liquidity_ratio,
+                isLiquiditySufficient: raw.summary.is_liquidity_sufficient,
+                shortfall: raw.summary.shortfall,
+                nextRedemptionDate: raw.summary.next_redemption_date,
+                isOverdue: raw.summary.is_overdue,
+            },
+            redemptionsByDate: raw.redemptions_by_date.map((item) => ({
+                date: item.date,
+                assets: item.assets,
+                daysUntilDue: item.days_until_due,
+                isOverdue: item.is_overdue,
+            })),
+        };
+    }
+    catch (e) {
+        core_1.Logger.log.error('getVaultPendingRedemptions', e, {
+            vault,
+            pastDays,
+            futureDays,
+        });
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        throw new Error(`#getVaultPendingRedemptions::${vault}:${errorMessage}`);
+    }
+}
 async function getPreviewRedemption({ vault, sharesAmount, options, }) {
     try {
         if (!vault)
             throw new Error('Vault address parameter is undefined.');
+        (0, utils_3.assertNotStellar)(vault, 'Preview redemption');
         if (!(0, ethers_1.isAddress)(vault)) {
             throw new Error(`Vault parameter is not an address: ${String(vault)}`);
         }
@@ -1732,6 +2059,7 @@ async function getWithdrawalRequestsWithStatus(params) {
         const provider = (0, core_1.createProvider)(options.rpcUrl);
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vaultAddress, options?.headers, false, false))?.[0];
         if (!tokenizedVault) {
+            core_1.Logger.log.warn('getWithdrawalRequestsWithStatus', `Vault not found in backend: ${vaultAddress}`);
             return [];
         }
         const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
@@ -1750,7 +2078,7 @@ async function getWithdrawalRequestsWithStatus(params) {
             }
         }
         catch (e) {
-            core_1.Logger.log.warn(`Failed to fetch lagDuration from vault, using default 1 day: ${e instanceof Error ? e.message : 'Unknown error'}`);
+            core_1.Logger.log.warn('getWithdrawalRequestsWithStatus', `Failed to fetch lagDuration from vault ${vaultAddress}, using default 1 day — status determinations may be inaccurate: ${e instanceof Error ? e.message : 'Unknown error'}`);
         }
         const [withdrawalRequests, processedEvents] = await Promise.all([
             (0, vaults_1.getSubgraphWithdrawRequests)(vaultAddress, provider),
@@ -1783,7 +2111,7 @@ async function getWithdrawalRequestsWithStatus(params) {
                     }
                 }
                 catch (e) {
-                    core_1.Logger.log.warn(`Failed to decode processed transaction ${processed.transactionHash}: ${e instanceof Error ? e.message : 'Unknown error'}`);
+                    core_1.Logger.log.warn('getWithdrawalRequestsWithStatus', `Failed to decode processed transaction ${processed.transactionHash}: ${e instanceof Error ? e.message : 'Unknown error'}`);
                 }
             }
             const requestedEpoch = Math.floor(processed.requested.getTime() / 1000);
@@ -1815,10 +2143,8 @@ async function getWithdrawalRequestsWithStatus(params) {
             }
             const dateKey = (0, date_utils_1.formatDateKey)(processed.decodedDate.year, processed.decodedDate.month, processed.decodedDate.day);
             const key = `${processed.receiver.toLowerCase()}:${dateKey}`;
-            if (processedMap.has(key)) {
-                core_1.Logger.log.warn('getWithdrawalRequestsWithStatus', `Duplicate processed event for key ${key}, overwriting previous entry`);
-            }
-            processedMap.set(key, processed);
+            const existing = processedMap.get(key) ?? [];
+            processedMap.set(key, [...existing, processed]);
         }
         const chainId = tokenizedVault.chain;
         const effectiveLookbackBlocks = params.lookbackBlocks ?? (0, core_1.determineBlockCutoff)(chainId);
@@ -1834,7 +2160,10 @@ async function getWithdrawalRequestsWithStatus(params) {
             let assetsReceived;
             const dateKey = (0, date_utils_1.formatDateKey)(claimableDate.year, claimableDate.month, claimableDate.day);
             const lookupKey = `${req.receiverAddr.toLowerCase()}:${dateKey}`;
-            const processedEvent = processedMap.get(lookupKey);
+            const processedEvents = processedMap.get(lookupKey);
+            const processedEvent = processedEvents && processedEvents.length > 0
+                ? processedEvents.shift()
+                : undefined;
             if (processedEvent) {
                 status = 'processed';
                 processedTxHash = processedEvent.transactionHash;
@@ -1859,7 +2188,13 @@ async function getWithdrawalRequestsWithStatus(params) {
                         return BigInt(req.shares);
                     }
                     catch {
-                        return BigInt(Math.trunc(Number(req.shares)));
+                        const truncated = Math.trunc(Number(req.shares));
+                        if (!Number.isFinite(truncated)) {
+                            core_1.Logger.log.warn('getWithdrawalRequestsWithStatus', `Cannot parse shares value "${req.shares}" — defaulting to 0`);
+                            return BigInt(0);
+                        }
+                        core_1.Logger.log.info('getWithdrawalRequestsWithStatus', `Truncated decimal shares "${req.shares}" → ${truncated}`);
+                        return BigInt(truncated);
                     }
                 })(),
                 receiver: req.receiverAddr,