@augustdigital/sdk 4.24.9 → 4.24.10-alpha-4

package/lib/modules/vaults/getters.js

@@ -57,22 +57,32 @@ 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");
 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 {
@@ -81,7 +91,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);
@@ -100,7 +115,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 = {
@@ -204,7 +225,6 @@ async function getVaultAllocations(vault, options) {
     const protocolExposure = [];
     const tokenExposure = [];
     let cefiExposure = [];
-    const cefiBorrowerResponses = {};
     const otcPositions = {};
     const defiPerBorrower = {};
     const exposurePerCategory = {
@@ -322,21 +342,26 @@ 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());
-                    cefiBorrowerResponses[borrower] = cefiRes;
-                    cefiExposure = cefiRes;
+                    cefiExposure = [...cefiExposure, ...cefiRes];
                 }
             }
             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());
@@ -344,7 +369,7 @@ async function getVaultAllocations(vault, options) {
                 }
             }
             catch (e) {
-                console.error('#getVaultAllocations::otc:', e);
+                core_1.Logger.log.error('getVaultAllocations:otc', e, { borrower });
             }
         }
     }
@@ -371,6 +396,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) {
@@ -408,14 +444,14 @@ async function getVaultAvailableRedemptions({ vault, wallet, options, }) {
                 core_1.Logger.log.warn('getVaultAvailableRedemptions', `Skipping invalid event: ${ev}`);
                 continue;
             }
-            const date = new Date(Number(ev.timestamp_) * 1000);
             let month;
             let day;
             let year;
             if (version === 'evm-2') {
-                month = date.getMonth() + 1;
-                day = date.getDate();
-                year = date.getFullYear();
+                const claimable = (0, date_utils_1.computeClaimableDate)(Number(ev.timestamp_), lagDuration);
+                year = claimable.year;
+                month = claimable.month;
+                day = claimable.day;
             }
             if (!ev.year || !ev.month || !ev.day || !ev.receiverAddr) {
                 if (version !== 'evm-2') {
@@ -432,22 +468,34 @@ async function getVaultAvailableRedemptions({ vault, wallet, options, }) {
                 }
             }
             const fullDate = version === 'evm-2'
-                ? new Date(Number(ev.timestamp_) * 1000)
+                ? new Date(Date.UTC(year, month - 1, day))
                 : new Date(Number(ev.year), Number(ev.month) - 1, Number(ev.day));
-            const foundRedemptionAgainstClaim = withdrawalProcesseds.find((h) => version === 'evm-2'
-                ? new Date(h.timestamp_).toDateString() === fullDate.toDateString() &&
-                    h.receiverAddr === ev.receiverAddr
-                : new Date(h.processedOn).toDateString() === fullDate.toDateString() &&
-                    h.receiverAddr === ev.receiverAddr);
+            const requestDateKey = version === 'evm-2'
+                ? (0, date_utils_1.formatDateKey)(year, month, day)
+                : (0, date_utils_1.formatDateKey)(Number(ev.year), Number(ev.month), Number(ev.day));
+            const foundRedemptionAgainstClaim = withdrawalProcesseds.find((h) => {
+                const proc = h;
+                if (proc.receiverAddr !== ev.receiverAddr)
+                    return false;
+                if (version === 'evm-2') {
+                    const procDate = new Date(Number(proc.timestamp_) * 1000);
+                    const procKey = (0, date_utils_1.formatDateKey)(procDate.getUTCFullYear(), procDate.getUTCMonth() + 1, procDate.getUTCDate());
+                    return procKey === requestDateKey;
+                }
+                const procDate = new Date(proc.processedOn);
+                const procKey = (0, date_utils_1.formatDateKey)(procDate.getUTCFullYear(), procDate.getUTCMonth() + 1, procDate.getUTCDate());
+                return procKey === requestDateKey;
+            });
             if (wallet && (0, ethers_1.isAddress)(wallet)) {
                 if (ev?.receiverAddr?.toLowerCase() === wallet.toLowerCase()) {
                     const alreadyRedeemed = version === 'evm-2'
                         ? withdrawalProcesseds.find((red) => {
-                            if (Number(ev.timestamp_) * 1000 + lagDuration * 1000 <=
-                                1000 * Number(red.timestamp_) &&
-                                red.receiverAddr.toLowerCase() === wallet.toLowerCase()) {
-                                return red;
+                            if (red.receiverAddr.toLowerCase() !== wallet.toLowerCase()) {
+                                return false;
                             }
+                            const redDate = new Date(Number(red.timestamp_) * 1000);
+                            const redKey = (0, date_utils_1.formatDateKey)(redDate.getUTCFullYear(), redDate.getUTCMonth() + 1, redDate.getUTCDate());
+                            return redKey === requestDateKey;
                         })
                         : availableRedemptions.find((red) => BigInt(red.day.raw) === BigInt(ev.day) &&
                             BigInt(red.month.raw) === BigInt(ev.month) &&
@@ -463,14 +511,9 @@ async function getVaultAvailableRedemptions({ vault, wallet, options, }) {
                                         }
                                     }
                                     if (!alreadyRedeemed) {
-                                        const pendingCondition = Number(ev.timestamp_) * 1000 + 1000 * lagDuration <
-                                            Date.now();
+                                        const claimable = (0, date_utils_1.computeClaimableDate)(Number(ev.timestamp_), lagDuration);
+                                        const pendingCondition = (0, date_utils_1.isClaimableNow)(claimable.epoch, Math.floor(Date.now() / 1000));
                                         if (pendingCondition) {
-                                            const date = new Date(Number(year), Number(month) - 1, Number(day));
-                                            date.setDate(date.getDate() + lagDuration / (24 * 60 * 60));
-                                            year = date.getFullYear();
-                                            month = date.getMonth() + 1;
-                                            day = date.getDate();
                                             try {
                                                 const burnableAmount = (await vaultContract?.getBurnableAmountByReceiver?.(BigInt(year), BigInt(month), BigInt(day), (0, ethers_1.getAddress)(ev.receiverAddr))) || BigInt(0);
                                                 const claimAmount = BigInt(ev.shares) || BigInt(0);
@@ -515,15 +558,13 @@ async function getVaultAvailableRedemptions({ vault, wallet, options, }) {
                                 default: {
                                     const trueClaimableAmount = await vaultContract?.getClaimableAmountByReceiver?.(BigInt(ev.year), BigInt(ev.month), BigInt(ev.day), (0, ethers_1.getAddress)(wallet));
                                     if (trueClaimableAmount > BigInt(0)) {
-                                        const pendingCondition = Number(ev.timestamp_) * 1000 + 1000 * lagDuration <
-                                            Date.now();
+                                        const v1Claimable = (0, date_utils_1.computeClaimableDate)(Number(ev.timestamp_), lagDuration);
+                                        const pendingCondition = (0, date_utils_1.isClaimableNow)(v1Claimable.epoch, Math.floor(Date.now() / 1000));
                                         if (pendingCondition) {
                                             try {
-                                                const date = new Date(Number(ev.year), Number(ev.month) - 1, Number(ev.day));
-                                                date.setDate(date.getDate() + lagDuration / (24 * 60 * 60));
-                                                year = date.getFullYear();
-                                                month = date.getMonth() + 1;
-                                                day = date.getDate();
+                                                year = v1Claimable.year;
+                                                month = v1Claimable.month;
+                                                day = v1Claimable.day;
                                                 const burnableAmount = (await vaultContract?.getBurnableAmountByReceiver?.(BigInt(year), BigInt(month), BigInt(day), (0, ethers_1.getAddress)(ev.receiverAddr))) || BigInt(0);
                                                 const claimAmount = trueClaimableAmount || BigInt(0);
                                                 if (burnableAmount >= claimAmount) {
@@ -617,58 +658,113 @@ 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))?.[0];
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, options?.headers, false, false))?.[0];
         if (!tokenizedVault) {
             return [];
         }
         const chainId = tokenizedVault.chain;
+        const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        const isV2 = version === 'evm-2';
+        const vaultAbi = isV2 ? TokenizedVaultV2_1.ABI_TOKENIZED_VAULT_V2 : abis_1.ABI_LENDING_POOL_V2;
         const poolContract = (0, core_1.createContract)({
             address: vault,
-            abi: abis_1.ABI_LENDING_POOL_V2,
+            abi: vaultAbi,
             provider,
         });
-        const logPromises = [];
         const currentBlock = await provider.getBlockNumber();
-        let startingBlock = currentBlock - (0, core_1.determineBlockSkipInternal)(chainId);
-        let endBlock = currentBlock;
+        const blockSkip = (0, core_1.determineBlockSkipInternal)(chainId);
         const cutoffBlock = currentBlock - (0, core_1.determineBlockCutoff)(chainId);
+        const BATCH_SIZE = 20;
+        core_1.Logger.log.info('getVaultRedemptionHistory', {
+            vault,
+            version,
+            isV2,
+            chainId,
+            currentBlock,
+            cutoffBlock,
+            blockSkip,
+            totalRangeBlocks: currentBlock - cutoffBlock,
+        });
+        const ranges = [];
+        let endBlock = currentBlock;
         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 fromBlock = Math.max(endBlock - blockSkip, cutoffBlock);
+            ranges.push({ from: fromBlock, to: endBlock });
+            endBlock = fromBlock - 1;
+        }
+        core_1.Logger.log.info('getVaultRedemptionHistory', {
+            totalBatches: Math.ceil(ranges.length / BATCH_SIZE),
+            totalChunks: ranges.length,
+            firstRange: ranges[0],
+            lastRange: ranges[ranges.length - 1],
+        });
+        const logs = [];
+        for (let i = 0; i < ranges.length; i += BATCH_SIZE) {
+            const batch = ranges.slice(i, i + BATCH_SIZE);
+            const batchResults = await Promise.all(batch.map((r) => poolContract.queryFilter('WithdrawalProcessed', BigInt(r.from), BigInt(r.to))));
+            const batchLogs = batchResults.flat();
+            logs.push(...batchLogs);
+        }
+        const iface = new ethers_1.ethers.Interface(isV2
+            ? [
+                'event WithdrawalProcessed(uint256 assetsAmount, address indexed receiverAddr)',
+            ]
+            : [
+                'event WithdrawalProcessed(uint256 assetsAmount, uint256 processedOn, address receiverAddr, uint256 requestedOn)',
+            ]);
         const decimals = await (0, core_1.getDecimals)(provider, vault);
+        let blockTimestamps;
+        if (isV2 && logs.length > 0) {
+            const uniqueBlocks = [...new Set(logs.map((l) => l.blockNumber))];
+            const blockResults = await Promise.all(uniqueBlocks.map((bn) => provider.getBlock(bn)));
+            blockTimestamps = new Map();
+            blockResults.forEach((block) => {
+                if (block)
+                    blockTimestamps.set(block.number, block.timestamp);
+            });
+        }
         const redemptions = [];
-        events?.forEach((ev) => {
+        logs.forEach((log) => {
+            const ev = iface.parseLog(log);
             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,
-                    });
-                }
+            let item;
+            if (isV2) {
+                const [assetsAmount, receiverAddr] = ev.args;
+                const blockTs = blockTimestamps?.get(log.blockNumber) ?? 0;
+                const blockDate = new Date(blockTs * 1000);
+                item = {
+                    receiver: receiverAddr,
+                    amount: (0, core_1.toNormalizedBn)(assetsAmount, decimals),
+                    processed: blockDate,
+                    requested: new Date(0),
+                    vault,
+                    transactionHash: log.transactionHash,
+                };
             }
             else {
-                redemptions.push({
+                const [assetsAmount, processedOn, receiverAddr, requestedOn] = ev.args;
+                item = {
                     receiver: receiverAddr,
                     amount: (0, core_1.toNormalizedBn)(assetsAmount, decimals),
                     processed: new Date(Number(processedOn) * 1000),
                     requested: new Date(Number(requestedOn) * 1000),
                     vault,
-                });
+                    transactionHash: log.transactionHash,
+                };
+            }
+            if (wallet) {
+                if (item.receiver?.toLowerCase() === wallet.toLowerCase()) {
+                    redemptions.push(item);
+                }
+            }
+            else {
+                redemptions.push(item);
             }
         });
         core_1.Logger.log.info('getVaultRedemptionHistory', redemptions.slice(0, 1));
@@ -694,10 +790,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) {
@@ -713,6 +809,17 @@ async function getVaultPositions({ vault, wallet, solanaWallet, options, }) {
                         walletBalance: balance,
                     };
                 }
+                if ((0, utils_3.isStellarAddress)(v.address)) {
+                    core_1.Logger.log.warn('getVaultPositions', 'Position tracking not yet available for Stellar vaults', { vault: v.address });
+                    return {
+                        vault: v.address,
+                        status: 'NOT_SUPPORTED',
+                        availableRedemptions: [],
+                        pendingRedemptions: [],
+                        redeemable: (0, core_1.toNormalizedBn)(0),
+                        walletBalance: (0, core_1.toNormalizedBn)(0),
+                    };
+                }
                 const provider = (0, core_1.createProvider)(options.rpcUrl);
                 let decimals;
                 const version = (0, core_1.getVaultVersionV2)(v);
@@ -933,6 +1040,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': {
@@ -951,14 +1076,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,
@@ -977,12 +1094,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,
@@ -1197,7 +1318,8 @@ async function getYieldLastRealizedOn({ vault, options, }) {
                 assetsUpdatedOn = await contract.assetsUpdatedOn();
                 break;
             }
-            case 'sol-0': {
+            case 'sol-0':
+            case 'stellar-0': {
                 return 0;
             }
             default: {
@@ -1218,6 +1340,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))
@@ -1237,6 +1360,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 () => {
@@ -1293,9 +1440,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 {
@@ -1311,7 +1471,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 {
@@ -1353,6 +1513,33 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
             else {
                 currentShares = await vaultContract.balanceOf(wallet);
             }
+            if (lzVaultKey && tokenizedVault.receipt_token_integrations?.length) {
+                const remoteBalances = await Promise.all(tokenizedVault.receipt_token_integrations
+                    .filter((rti) => rti.chain !== tokenizedVault.chain && rti.address && rti.chain)
+                    .map(async (rti) => {
+                    try {
+                        const rpcUrls = (0, core_1.getFallbackRpcUrls)(rti.chain);
+                        if (!rpcUrls.length) {
+                            core_1.Logger.log.warn('getVaultUserLifetimePnl:lzRemoteBalance', `No RPC URL for chain ${rti.chain}, skipping balance check`);
+                            return BigInt(0);
+                        }
+                        const remoteProvider = (0, core_1.createProvider)(rpcUrls[0]);
+                        const remoteTokenContract = (0, core_1.createContract)({
+                            provider: remoteProvider,
+                            address: rti.address,
+                            abi: abis_1.ABI_ERC20,
+                        });
+                        return (await remoteTokenContract.balanceOf(wallet));
+                    }
+                    catch (e) {
+                        core_1.Logger.log.warn('getVaultUserLifetimePnl:lzRemoteBalance', `Failed to fetch balance on chain ${rti.chain}: ${e}`);
+                        return BigInt(0);
+                    }
+                }));
+                for (const bal of remoteBalances) {
+                    currentShares += bal;
+                }
+            }
             if (version === 'evm-2') {
                 sharePriceRaw = await vaultContract.getSharePrice();
             }
@@ -1393,7 +1580,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;
@@ -1439,6 +1626,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({
@@ -1560,6 +1748,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)}`);
         }
@@ -1584,6 +1773,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)}`);
         }
@@ -1606,10 +1796,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)}`);
         }
@@ -1652,4 +1910,179 @@ async function getPreviewRedemption({ vault, sharesAmount, options, }) {
         throw new Error(`Failed to preview redemption for ${vault}: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
+async function decodeProcessingTransaction(txHash, provider, iface) {
+    const tx = await provider.getTransaction(txHash);
+    if (!tx) {
+        return {
+            functionName: 'unknown',
+            year: 0,
+            month: 0,
+            day: 0,
+            error: 'Transaction not found',
+        };
+    }
+    return (0, call_data_decoder_1.decodeWithdrawalProcessing)(tx.data, iface);
+}
+async function getWithdrawalRequestsWithStatus(params) {
+    try {
+        const { vault, receiver, options } = params;
+        if (!vault || !(0, ethers_1.isAddress)(vault)) {
+            throw new Error('Invalid vault address');
+        }
+        const vaultAddress = (0, ethers_1.getAddress)(vault);
+        const provider = (0, core_1.createProvider)(options.rpcUrl);
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vaultAddress, options?.headers, false, false))?.[0];
+        if (!tokenizedVault) {
+            return [];
+        }
+        const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        const isV2 = version === 'evm-2';
+        const vaultAbi = isV2 ? TokenizedVaultV2_1.ABI_TOKENIZED_VAULT_V2 : abis_1.ABI_LENDING_POOL_V2;
+        const vaultContract = (0, core_1.createContract)({
+            address: vaultAddress,
+            abi: vaultAbi,
+            provider,
+        });
+        let lagDuration = 86400;
+        try {
+            const lagValue = await vaultContract.lagDuration?.();
+            if (lagValue !== undefined && lagValue !== null) {
+                lagDuration = Number(lagValue);
+            }
+        }
+        catch (e) {
+            core_1.Logger.log.warn(`Failed to fetch lagDuration from vault, using default 1 day: ${e instanceof Error ? e.message : 'Unknown error'}`);
+        }
+        const [withdrawalRequests, processedEvents] = await Promise.all([
+            (0, vaults_1.getSubgraphWithdrawRequests)(vaultAddress, provider),
+            getVaultRedemptionHistory({
+                vault: vaultAddress,
+                wallet: receiver,
+                options,
+            }),
+        ]);
+        if (!withdrawalRequests.length) {
+            return [];
+        }
+        const filteredRequests = receiver
+            ? withdrawalRequests.filter((req) => req.receiverAddr?.toLowerCase() === receiver.toLowerCase())
+            : withdrawalRequests;
+        const iface = new ethers_1.Interface(vaultAbi);
+        const decodedProcessed = await Promise.all((processedEvents || []).map(async (processed) => {
+            if (processed.transactionHash) {
+                try {
+                    const decoded = await decodeProcessingTransaction(processed.transactionHash, provider, iface);
+                    if (!decoded.error) {
+                        return {
+                            ...processed,
+                            decodedDate: {
+                                year: decoded.year,
+                                month: decoded.month,
+                                day: decoded.day,
+                            },
+                        };
+                    }
+                }
+                catch (e) {
+                    core_1.Logger.log.warn(`Failed to decode processed transaction ${processed.transactionHash}: ${e instanceof Error ? e.message : 'Unknown error'}`);
+                }
+            }
+            const requestedEpoch = Math.floor(processed.requested.getTime() / 1000);
+            if (requestedEpoch > 0) {
+                const fallbackDate = (0, date_utils_1.computeClaimableDate)(requestedEpoch, lagDuration);
+                return {
+                    ...processed,
+                    decodedDate: {
+                        year: fallbackDate.year,
+                        month: fallbackDate.month,
+                        day: fallbackDate.day,
+                    },
+                };
+            }
+            const processedDate = processed.processed;
+            return {
+                ...processed,
+                decodedDate: {
+                    year: processedDate.getUTCFullYear(),
+                    month: processedDate.getUTCMonth() + 1,
+                    day: processedDate.getUTCDate(),
+                },
+            };
+        }));
+        const processedMap = new Map();
+        for (const processed of decodedProcessed) {
+            if (!processed.decodedDate) {
+                continue;
+            }
+            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 chainId = tokenizedVault.chain;
+        const effectiveLookbackBlocks = params.lookbackBlocks ?? (0, core_1.determineBlockCutoff)(chainId);
+        const lookbackSeconds = effectiveLookbackBlocks * (0, core_1.determineSecondsPerBlock)(chainId);
+        const results = [];
+        const now = Math.floor(Date.now() / 1000);
+        const lookbackCutoff = now - lookbackSeconds;
+        for (const req of filteredRequests) {
+            const requestTimestamp = Number(req.timestamp_);
+            const claimableDate = (0, date_utils_1.computeClaimableDate)(requestTimestamp, lagDuration);
+            let status = 'pending';
+            let processedTxHash;
+            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);
+            if (processedEvent) {
+                status = 'processed';
+                processedTxHash = processedEvent.transactionHash;
+                try {
+                    assetsReceived = BigInt(processedEvent.amount.raw);
+                }
+                catch (e) {
+                    core_1.Logger.log.warn(`Failed to parse assets as BigInt: ${e}`);
+                }
+            }
+            else if (claimableDate.epoch < lookbackCutoff) {
+                continue;
+            }
+            else if ((0, date_utils_1.isClaimableNow)(claimableDate.epoch, now)) {
+                status = 'ready_to_claim';
+            }
+            results.push({
+                transactionHash: req.transactionHash_,
+                requestTimestamp,
+                shares: (() => {
+                    try {
+                        return BigInt(req.shares);
+                    }
+                    catch {
+                        return BigInt(Math.trunc(Number(req.shares)));
+                    }
+                })(),
+                receiver: req.receiverAddr,
+                claimableDate: {
+                    year: claimableDate.year,
+                    month: claimableDate.month,
+                    day: claimableDate.day,
+                },
+                claimableEpoch: claimableDate.epoch,
+                status,
+                processedTransactionHash: processedTxHash,
+                assetsReceived,
+            });
+        }
+        return results;
+    }
+    catch (e) {
+        core_1.Logger.log.error('getWithdrawalRequestsWithStatus', e, {
+            vaultAddress: params.vault,
+            hasReceiver: !!params.receiver,
+        });
+        throw new Error(`Failed to get withdrawal requests with status: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
 //# sourceMappingURL=getters.js.map