@upshiftfinance/sdk 0.0.0-stage → 0.1.0

package/lib/services/subgraph/vaults.js

@@ -0,0 +1,1282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOldSubgraphSchema = isOldSubgraphSchema;
+exports.getSubgraphWithdrawRequests = getSubgraphWithdrawRequests;
+exports.getSubgraphWithdrawProccessed = getSubgraphWithdrawProccessed;
+exports.getSubgraphAllWithdrawals = getSubgraphAllWithdrawals;
+exports.getSubgraphUserHistory = getSubgraphUserHistory;
+exports.getSubgraphVaultHistory = getSubgraphVaultHistory;
+exports.getSubgraphUserTransfers = getSubgraphUserTransfers;
+exports.getSubgraphUserReserveDeposits = getSubgraphUserReserveDeposits;
+const ethers_1 = require("ethers");
+const slack_1 = require("../../core/logger/slack");
+const fetcher_1 = require("./fetcher");
+const schema_1 = require("./schema");
+const core_1 = require("../../core");
+const fetcher_2 = require("../../modules/vaults/fetcher");
+/**
+ * Utils
+ */
+const GOLDSKY_API_KEY = '';
+// Dedupe window for "Missing Subgraph" alerts (per pool).
+const MISSING_SUBGRAPH_ALERT_TTL_MS = 60 * 60 * 1000; // 1 hour
+/**
+ * Emit a "Missing Subgraph" Slack alert at most once per pool per TTL.
+ *
+ * `getDefaultSubgraphUrl` now returns `undefined` for vaults with no metadata or
+ * hardcoded subgraph URL, which makes the readers' `if (!goldskyUrl)` branches
+ * reachable (previously the fabricated URL was always truthy, so they were dead
+ * code). Portfolio/history flows loop over every vault, so alerting on each read
+ * would flood the webhook for every metadata-less vault. Deduping per pool
+ * surfaces a genuinely-missing subgraph without the flood.
+ *
+ * This is the durable signal for BOTH ways a vault's subgraph can be broken — no
+ * URL configured, and a URL that answers non-200 (a deleted subgraph 404s). The
+ * readers deliberately log those per-request at `warn` rather than `error`: at
+ * `error` each one became a billed Sentry issue on every portfolio read, which
+ * cost over 2M events in 30 days across a handful of vaults. The volume is
+ * per-request, but the condition is per-vault, so this alert is where it belongs.
+ *
+ * @param args.source - Reader function name, for the alert body.
+ * @param args.pool - Vault address (used as the dedupe key, lowercased).
+ * @param args.chainId - Chain id for the alert context, or a thunk resolving
+ *   it. Every current caller has the id in scope and passes it directly. The
+ *   thunk form exists for a caller that would otherwise have to resolve the id
+ *   eagerly on every non-200 response — it is invoked only after the dedupe
+ *   gate passes, so a suppressed alert costs nothing. No such caller exists
+ *   today; if none appears, this union and the deferred branch below can go.
+ * @param args.reason - Why the subgraph is unusable. Defaults to the
+ *   missing-URL case; pass the HTTP status for a URL that resolved but failed.
+ * @param args.slackWebookUrl - Optional override webhook URL.
+ */
+function alertMissingSubgraphOnce(args) {
+    const key = `missing-subgraph-alert-${args.pool.toLowerCase()}`;
+    if (core_1.CACHE.has(key))
+        return;
+    core_1.CACHE.set(key, true, { ttl: MISSING_SUBGRAPH_ALERT_TTL_MS });
+    const send = (chainId) => slack_1.SLACK.error({
+        title: 'Missing Subgraph',
+        error: `#${args.source}: ${args.reason ?? 'goldsky url is undefined'}`,
+        poolAddress: args.pool,
+        chainId,
+        slackWebookUrl: args.slackWebookUrl || '',
+    });
+    if (typeof args.chainId === 'number') {
+        send(args.chainId);
+        return;
+    }
+    // Deferred id: the dedupe key is already set, so a rejection here would mute
+    // this pool for the full TTL without ever alerting. Release the key instead,
+    // leaving the next non-200 free to try again.
+    void args
+        .chainId()
+        .then(send, (e) => {
+        core_1.CACHE.delete(key);
+        core_1.Logger.log.warn('alertMissingSubgraphOnce', `chain id unresolved, alert skipped: ${e}`);
+    })
+        // `send` itself can reject (SLACK.error does its own fetch). Without this
+        // it escapes as an unhandled rejection instead of being contained here.
+        .catch((e) => {
+        core_1.Logger.log.warn('alertMissingSubgraphOnce', `alert send failed: ${e}`);
+    });
+}
+/**
+ * earnAUSD exists on both Ethereum and Monad, so it needs a _monad suffix
+ * to distinguish its Monad subgraph from the Ethereum one.
+ * Other Monad-native vaults (sausd, supermon, etc.) don't need this.
+ */
+function needsMonadSuffix(chainId, symbol) {
+    return chainId === 143 && symbol.toLowerCase() === 'earnausd';
+}
+/**
+ * Read the decimals of every distinct deposit asset in a batch of deposit
+ * rows, keyed by lowercased token address.
+ *
+ * Pre-deposit / evm-2 vaults accept multiple deposit assets whose decimals can
+ * differ from the vault's own (e.g. RLUSD at 18 deposited into a 6-decimal
+ * sentUSD vault). `transformUserHistory` must normalize each deposit against
+ * its own asset's decimals rather than the vault's, or an 18-decimal amount
+ * normalized at 6 decimals renders ~1e12× too large (a 0.5 deposit shows as
+ * "500B"). `getDecimals` is cached and in-flight-deduped, and the distinct-asset
+ * set is tiny (typically 1-3), so this is at most a handful of RPC reads.
+ *
+ * Native-token deposits carry a sentinel `assetIn` — either the zero address or
+ * {@link NATIVE_ADDRESS} — that has no on-chain `decimals()`. These are mapped
+ * directly to {@link EVM_NATIVE_DECIMALS} (18 on every supported EVM chain)
+ * instead of being read. Without this guard `getDecimals(ZeroAddress)` returns
+ * `0`, which the caller's `?? decimals` fallback cannot override (0 is not
+ * nullish), overstating a native deposit ~1e18×; and `getDecimals(NATIVE_ADDRESS)`
+ * reverts, silently dropping to the vault's decimals which may differ.
+ *
+ * Only successfully-read decimals are entered in the map; a non-native asset
+ * whose `decimals()` read fails is omitted so the caller falls back to the
+ * vault's decimals. This also lets the vault-decimals read run in parallel with
+ * this one (no fallback value is needed up front).
+ *
+ * @param provider - EVM contract runner used to read `decimals()`.
+ * @param deposits - Deposit rows from the subgraph; `assetIn` may be absent.
+ * @returns Map of lowercased asset address to decimals (native sentinels and
+ *   successful reads only).
+ */
+async function buildDepositAssetDecimals(provider, deposits) {
+    const map = new Map();
+    // Lowercased native-token sentinels: no ERC-20 `decimals()` exists to read.
+    const nativeSentinels = new Set([
+        ethers_1.ZeroAddress.toLowerCase(),
+        core_1.NATIVE_ADDRESS.toLowerCase(),
+    ]);
+    const unique = new Set();
+    for (const d of deposits ?? []) {
+        if (d?.assetIn)
+            unique.add(d.assetIn.toLowerCase());
+    }
+    await Promise.all([...unique].map(async (addr) => {
+        if (nativeSentinels.has(addr)) {
+            map.set(addr, core_1.EVM_NATIVE_DECIMALS);
+            return;
+        }
+        const dec = await (0, core_1.getDecimals)(provider, addr, false);
+        if (typeof dec === 'number')
+            map.set(addr, dec);
+    }));
+    return map;
+}
+function transformUserHistory(data, chainId, decimals, poolAddress, assetDecimals) {
+    //ok to return dupes even though withdraws will return dupe because we parse out duplicate txn hash on the FE
+    return [
+        ...(data.withdraws?.map((item) => ({
+            ...item,
+            contractId_: item.contractId_ || poolAddress,
+            address: item.receiver,
+            amount: item.assets,
+            chainId: chainId,
+            type: 'withdraw-processed',
+            transactionHash: item.transactionHash_,
+            timestamp: item.timestamp_,
+            decimals: decimals,
+            isInstant: true,
+        })) || []),
+        ...(data.withdrawalRequesteds?.map((item) => ({
+            ...item,
+            contractId_: item.contractId_ || poolAddress,
+            address: item.receiverAddr,
+            amount: item?.assets || item?.shares,
+            chainId: chainId,
+            type: 'withdraw-request',
+            transactionHash: item.transactionHash_,
+            timestamp: item.timestamp_,
+            decimals: decimals,
+        })) || []),
+        ...(data.withdrawalProcesseds?.map((item) => ({
+            ...item,
+            contractId_: item.contractId_ || poolAddress,
+            address: item.receiverAddr,
+            amount: item.assetsAmount,
+            chainId: chainId,
+            type: 'withdraw-processed',
+            transactionHash: item.transactionHash_,
+            timestamp: item.timestamp_,
+            decimals: decimals,
+        })) || []),
+        ...(data.deposits?.map((item) => {
+            // Pair the decimals to the amount's denomination. `assets` (evm-1) is
+            // already in the vault's underlying, so it keeps the vault decimals.
+            // Only `amountIn` (evm-2 / pre-deposit) is denominated in `assetIn`,
+            // which may differ from the vault (e.g. RLUSD 18 → sentUSD 6) and would
+            // otherwise overstate the amount ~1e12×. Using the same source for both
+            // avoids a denomination/decimals mismatch, and the truthy `assetIn`
+            // guard drops empty-string addresses back to the vault decimals.
+            const assetKey = !item?.assets && item.assetIn ? item.assetIn.toLowerCase() : undefined;
+            return {
+                ...item,
+                contractId_: item.contractId_ || poolAddress,
+                chainId: chainId,
+                type: 'deposit',
+                address: item?.sender || item?.senderAddr,
+                amount: item?.assets || item?.amountIn,
+                transactionHash: item.transactionHash_,
+                timestamp: item.timestamp_,
+                decimals: (assetKey ? assetDecimals?.get(assetKey) : undefined) ?? decimals,
+            };
+        }) || []),
+    ];
+}
+function sortUserHistory(data, chainId, decimals, poolAddress, assetDecimals) {
+    if (!(data && chainId && decimals))
+        return [];
+    return transformUserHistory(data, chainId, decimals, poolAddress, assetDecimals).sort((a, b) => Number(a.timestamp_) - Number(b.timestamp_));
+}
+// queries
+const WITHDRAWALS_REQUESTED_QUERY_PROPS = `
+    id
+    day
+    month
+    year
+    shares
+    assets
+    receiverAddr
+    ownerAddr
+    block_number
+    timestamp_
+    transactionHash_
+    contractId_
+`;
+const EVM_V2_WITHDRAWALS_REQUESTED_QUERY_PROPS = `
+    id
+    shares
+    receiverAddr
+    holderAddr
+    block_number
+    timestamp_
+    transactionHash_
+    contractId_
+`;
+const WITHDRAWALS_QUERY_PROPS = `
+    id
+    transactionHash_
+    timestamp_
+    block_number
+    contractId_
+    assets
+    receiver
+    sender
+    `;
+const EVM_V2_WITHDRAWALS_QUERY_PROPS = `
+    id
+    transactionHash_
+    timestamp_
+    block_number
+    contractId_
+    assets
+    receiver
+    sender
+    shares
+    owner
+    `;
+const WITHDRAWALS_PROCESSED_QUERY_PROPS = `
+    id
+    processedOn
+    requestedOn
+    receiverAddr
+    assetsAmount
+    block_number
+    timestamp_
+    contractId_
+    transactionHash_
+`;
+const EVM_V2_WITHDRAWALS_PROCESSED_QUERY_PROPS = `
+    id
+    receiverAddr
+    assetsAmount
+    block_number
+    timestamp_
+    contractId_
+    transactionHash_
+`;
+const DEPOSIT_QUERY_PROPS = `
+    id
+    assets
+    transactionHash_
+    timestamp_
+    contractId_
+    sender
+    shares
+    owner
+  `;
+const EVM_V2_DEPOSIT_QUERY_PROPS = `
+    id
+    assetIn
+    amountIn
+    transactionHash_
+    timestamp_
+    contractId_
+    senderAddr
+    receiverAddr
+  `;
+// New deployment process uses a different subgraph schema (no trailing underscores).
+// Vaults in SUBGRAPH_VAULT_URLS use the old schema; everything else uses the new schema.
+// GraphQL aliases map new-schema fields to what the SDK expects internally.
+function isOldSubgraphSchema(vaultSymbol) {
+    return (vaultSymbol?.toLowerCase() in
+        core_1.SUBGRAPH_VAULT_URLS);
+}
+// New schema query props (shared across evm-1 and evm-2 — the new subgraph schema
+// normalized field names, so no per-version variants are needed)
+const NEW_DEPOSIT_QUERY_PROPS = `
+    id
+    assetIn
+    amountIn
+    transactionHash_: transactionHash
+    timestamp_: blockTimestamp
+    senderAddr
+    receiverAddr
+  `;
+// The `block_number: blockNumber` alias on these new-schema withdrawal prop
+// sets is required, not cosmetic: getWithdrawalRequestsWithStatus prunes by
+// `Number(req.block_number) >= blockCutoff` (per the ISubgraphBase contract).
+// New-schema subgraphs expose the field as `blockNumber`, so without the alias
+// it reads undefined → Number(undefined) is NaN → every request is pruned
+// (AUGUST-6514). Only the REQUESTED set is read today; the processed/withdrawals
+// aliases below are kept for the same type contract so the NaN prune can't recur.
+const NEW_WITHDRAWALS_REQUESTED_QUERY_PROPS = `
+    id
+    shares
+    receiverAddr
+    holderAddr
+    block_number: blockNumber
+    transactionHash_: transactionHash
+    timestamp_: blockTimestamp
+`;
+const NEW_WITHDRAWALS_PROCESSED_QUERY_PROPS = `
+    id
+    receiverAddr
+    assetsAmount
+    block_number: blockNumber
+    transactionHash_: transactionHash
+    timestamp_: blockTimestamp
+`;
+const NEW_WITHDRAWALS_QUERY_PROPS = `
+    id
+    transactionHash_: transactionHash
+    timestamp_: blockTimestamp
+    block_number: blockNumber
+    assets
+    receiver
+    sender
+    shares
+    owner
+    `;
+// New schema: transfer query props
+const NEW_TRANSFER_QUERY_PROPS = `
+    id
+    from
+    to
+    value
+    transactionHash_: transactionHash
+    timestamp_: blockTimestamp
+    block_number: blockNumber
+  `;
+const TRANSFER_QUERY_PROPS = `
+    id
+    from
+    to
+    value
+    transactionHash_
+    timestamp_
+    block_number
+    contractId_
+  `;
+/**
+ * Goldsky caps every list field at 1000 rows per request, so a busy vault's
+ * withdrawal entities silently truncate unless we page on `skip`. Both bounds
+ * are shared by every withdrawal reader below.
+ */
+const WITHDRAWAL_PAGE_SIZE = 1000;
+/**
+ * Upper bound on pages fetched per withdrawal reader (20 × 1000 = 20 000 rows
+ * per entity). A vault past this bound is logged and returns the rows gathered
+ * so far rather than looping on a subgraph that keeps reporting full pages.
+ */
+const WITHDRAWAL_MAX_PAGES = 20;
+/**
+ * Page a withdrawal query on `skip` until every requested entity returns a
+ * short page (fewer than {@link WITHDRAWAL_PAGE_SIZE} rows).
+ *
+ * Why: `withdrawalRequesteds` / `withdrawalProcesseds` were previously read
+ * with a single `first: 1000` request, so vaults with more than 1000 events
+ * lost their oldest rows (and `getWithdrawalRequestsWithStatus` under-counted
+ * pending requests). Mirrors the lockstep paging in
+ * {@link getSubgraphVaultHistory}; ordering is whatever `buildQuery` encodes
+ * (newest-first), and pages are concatenated in fetch order so the result
+ * stays sorted.
+ *
+ * @param source - Caller name for log attribution.
+ * @param goldskyUrl - Subgraph endpoint.
+ * @param buildQuery - Renders the GraphQL document for one page. Every entity
+ *   in `entityKeys` must carry `first: pageSize, skip: skip`.
+ * @param entityKeys - Top-level `data` keys to accumulate across pages.
+ * @returns The first page's HTTP status (so callers keep their existing
+ *   non-200 warn/alert path) plus the accumulated rows per entity. A later
+ *   page failing is logged and the rows gathered so far are returned.
+ *
+ * RPC budget: 1 request per 1000 rows of the largest entity, capped at
+ * {@link WITHDRAWAL_MAX_PAGES} requests.
+ */
+async function fetchPagedWithdrawals(source, goldskyUrl, buildQuery, entityKeys) {
+    const data = Object.fromEntries(entityKeys.map((key) => [key, []]));
+    let skip = 0;
+    for (let page = 0; page < WITHDRAWAL_MAX_PAGES; page++) {
+        const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, buildQuery(WITHDRAWAL_PAGE_SIZE, skip), GOLDSKY_API_KEY);
+        if (result.status !== 200) {
+            // First page failing is the caller's existing error path; a later page
+            // failing still yields whatever earlier pages accumulated.
+            if (skip === 0) {
+                return { status: result.status, statusText: result.statusText, data };
+            }
+            core_1.Logger.log.warn(source, `${result.statusText}::${result.status}: page fetch failed, returning partial rows`, { skip });
+            break;
+        }
+        const json = (await result.json());
+        let needMore = false;
+        for (const key of entityKeys) {
+            const rows = json?.data?.[key] ?? [];
+            data[key].push(...rows);
+            if (rows.length === WITHDRAWAL_PAGE_SIZE)
+                needMore = true;
+        }
+        if (!needMore)
+            break;
+        skip += WITHDRAWAL_PAGE_SIZE;
+        if (page === WITHDRAWAL_MAX_PAGES - 1) {
+            core_1.Logger.log.warn(source, `hit the ${WITHDRAWAL_MAX_PAGES}-page cap; older withdrawal rows were not fetched`, { skip });
+        }
+    }
+    return { status: 200, statusText: 'OK', data };
+}
+/**
+ *
+ * @param pool
+ * @param provider
+ * @returns
+ */
+async function getSubgraphWithdrawRequests(pool, provider, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)()) {
+    // setup
+    let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
+    if (vaultSymbol === undefined) {
+        core_1.Logger.log.warn('getSubgraphWithdrawRequests', `cannot find vault symbol for pool: ${pool}`);
+        return [];
+    }
+    const networkValue = await provider.provider.getNetwork();
+    const network = Number(networkValue.chainId);
+    if (needsMonadSuffix(network, vaultSymbol)) {
+        vaultSymbol = vaultSymbol.concat('_monad');
+    }
+    // sanitize
+    if (vaultSymbol === 'testWETHTSA') {
+        return [];
+    }
+    const vaultsMetadata = await (0, fetcher_2.fetchVaultMetadata)();
+    const { subgraph } = vaultsMetadata?.[vaultSymbol?.toLowerCase()] || {};
+    const goldskyUrl = subgraph ||
+        core_1.SUBGRAPH_VAULT_URLS[vaultSymbol?.toLowerCase()] ||
+        (0, core_1.getDefaultSubgraphUrl)(networkValue.name, vaultSymbol);
+    const requests = [];
+    if (!goldskyUrl) {
+        const chainId = await (0, core_1.getChainId)(provider);
+        core_1.Logger.log.warn('getSubgraphWithdrawRequests', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
+        alertMissingSubgraphOnce({
+            source: 'getSubgraphWithdrawRequests',
+            pool,
+            chainId,
+            slackWebookUrl,
+        });
+        return [];
+    }
+    const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool, undefined, false, false))?.[0];
+    const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
+    // Probe the deployed subgraph to learn its actual field schema (cached per
+    // URL) instead of guessing from the vault symbol. See resolveSubgraphSchema —
+    // the old symbol-map heuristic silently emptied this set for vaults deployed
+    // on the old template but absent from SUBGRAPH_VAULT_URLS (AUGUST-6568).
+    const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
+    const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
+    const withdrawalRequestedProps = useOldSchema
+        ? version === 'evm-2'
+            ? EVM_V2_WITHDRAWALS_REQUESTED_QUERY_PROPS
+            : WITHDRAWALS_REQUESTED_QUERY_PROPS
+        : NEW_WITHDRAWALS_REQUESTED_QUERY_PROPS;
+    const result = await fetchPagedWithdrawals('getSubgraphWithdrawRequests', goldskyUrl, (pageSize, skip) => `{
+      withdrawalRequesteds(
+        first: ${pageSize},
+        skip: ${skip},
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+      ) {
+        ${withdrawalRequestedProps}
+      }
+    }`, ['withdrawalRequesteds']);
+    if (result.status !== 200) {
+        core_1.Logger.log.warn('getSubgraphWithdrawRequests', `${result.statusText}::${result.status}: ${vaultSymbol}::${pool}`);
+        alertMissingSubgraphOnce({
+            source: 'getSubgraphWithdrawRequests',
+            pool,
+            // Already resolved at the top of this function — no re-fetch, and the
+            // alert fires synchronously.
+            chainId: network,
+            reason: `subgraph returned ${result.status} ${result.statusText}`,
+            slackWebookUrl,
+        });
+        return [];
+    }
+    requests.push(...result.data.withdrawalRequesteds);
+    return requests;
+}
+async function getSubgraphWithdrawProccessed(pool, provider, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)()) {
+    try {
+        // setup
+        let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
+        if (vaultSymbol === undefined) {
+            core_1.Logger.log.warn('getSubgraphWithdrawProccessed', `cannot find vault symbol for pool: ${pool}`);
+            return [];
+        }
+        const networkValue = await provider.provider.getNetwork();
+        const network = Number(networkValue.chainId);
+        if (needsMonadSuffix(network, vaultSymbol)) {
+            vaultSymbol = vaultSymbol.concat('_monad');
+        }
+        const noWithdrawalProcessed = vaultSymbol === 'agETH';
+        // sanitize
+        if (vaultSymbol === 'testWETHTSA' || noWithdrawalProcessed) {
+            return [];
+        }
+        const vaultsMetadata = await (0, fetcher_2.fetchVaultMetadata)();
+        const { subgraph } = vaultsMetadata?.[vaultSymbol?.toLowerCase()] || {};
+        const goldskyUrl = subgraph ||
+            core_1.SUBGRAPH_VAULT_URLS[vaultSymbol?.toLowerCase()] ||
+            (0, core_1.getDefaultSubgraphUrl)(networkValue.name, vaultSymbol);
+        const requests = [];
+        if (!goldskyUrl) {
+            const chainId = await (0, core_1.getChainId)(provider);
+            core_1.Logger.log.warn('getSubgraphWithdrawProccessed.missing-subgraph-url', `goldsky url is undefined: ${vaultSymbol}::${pool}`, { chainId });
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphWithdrawProccessed',
+                pool,
+                chainId,
+                slackWebookUrl,
+            });
+            return [];
+        }
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool, undefined, false, false))?.[0];
+        const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
+        const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
+        const withdrawalProcessedProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_WITHDRAWALS_PROCESSED_QUERY_PROPS
+                : WITHDRAWALS_PROCESSED_QUERY_PROPS
+            : NEW_WITHDRAWALS_PROCESSED_QUERY_PROPS;
+        const result = await fetchPagedWithdrawals('getSubgraphWithdrawProccessed', goldskyUrl, (pageSize, skip) => `{
+        withdrawalProcesseds (
+          first: ${pageSize},
+          skip: ${skip},
+          orderBy: ${orderByTimestamp},
+          orderDirection: desc,
+        ) {
+          ${withdrawalProcessedProps}
+        }
+      }`, ['withdrawalProcesseds']);
+        if (result.status !== 200) {
+            core_1.Logger.log.warn('getSubgraphWithdrawProccessed', `${result.statusText}::${result.status}: ${vaultSymbol}::${pool}`);
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphWithdrawProccessed',
+                pool,
+                // Already resolved at the top of this function — no re-fetch, and the
+                // alert fires synchronously.
+                chainId: network,
+                reason: `subgraph returned ${result.status} ${result.statusText}`,
+                slackWebookUrl,
+            });
+            return [];
+        }
+        requests.push(...result.data.withdrawalProcesseds);
+        return requests;
+    }
+    catch (e) {
+        core_1.Logger.log.error('getSubgraphWithdrawProccessed', e, { pool });
+        return [];
+    }
+}
+/**
+ * Fetch a vault's `withdrawalRequesteds` and `withdrawalProcesseds` from its
+ * Goldsky subgraph in one paged query.
+ *
+ * Without `receiver`, every wallet's rows are returned (up to the page cap) —
+ * on busy vaults that is ~0.9 MB per call. Pass `receiver` when the caller only
+ * needs one wallet's rows: both entities are then filtered server-side with
+ * `where: { receiverAddr }` (the same filter {@link getSubgraphUserHistory}
+ * uses), which shrinks the response to that wallet's rows (AUGUST-8317).
+ *
+ * Side effects: one schema probe per subgraph URL (cached) plus one Goldsky
+ * POST per 1,000-row page.
+ *
+ * @param pool - Vault contract address.
+ * @param provider - Contract runner, used to resolve the vault symbol/network.
+ * @param options - Optional settings.
+ * @param options.slackWebookUrl - Webhook for missing-subgraph alerts.
+ *   Defaults to {@link resolveSlackWebhookUrl}.
+ * @param options.receiver - Optional wallet; when a valid EVM address, only
+ *   rows whose `receiverAddr` matches it (case-insensitive) are fetched.
+ * @returns Both entity lists, newest first. Empty lists on any failure.
+ */
+async function getSubgraphAllWithdrawals(pool, provider, { slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)(), receiver, } = {}) {
+    let query = '';
+    try {
+        // setup
+        const errorReturnObj = {
+            withdrawalRequesteds: [],
+            withdrawalProcesseds: [],
+        };
+        let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
+        if (vaultSymbol === undefined) {
+            core_1.Logger.log.warn('getSubgraphAllWithdrawals', `cannot find vault symbol for pool: ${pool}`);
+            return errorReturnObj;
+        }
+        const networkValue = await provider.provider.getNetwork();
+        const network = Number(networkValue.chainId);
+        if (needsMonadSuffix(network, vaultSymbol)) {
+            vaultSymbol = vaultSymbol.concat('_monad');
+        }
+        const noWithdrawalProcessed = vaultSymbol === 'agETH';
+        // sanitize
+        if (vaultSymbol === 'testWETHTSA') {
+            return errorReturnObj;
+        }
+        const vaultsMetadata = await (0, fetcher_2.fetchVaultMetadata)();
+        const { subgraph } = vaultsMetadata?.[vaultSymbol?.toLowerCase()] || {};
+        const goldskyUrl = subgraph ||
+            core_1.SUBGRAPH_VAULT_URLS[vaultSymbol?.toLowerCase()] ||
+            (0, core_1.getDefaultSubgraphUrl)(networkValue.name, vaultSymbol);
+        if (!goldskyUrl) {
+            const chainId = await (0, core_1.getChainId)(provider);
+            core_1.Logger.log.warn('getSubgraphAllWithdrawals', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphAllWithdrawals',
+                pool,
+                chainId,
+                slackWebookUrl,
+            });
+            return errorReturnObj;
+        }
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool, undefined, false, false))?.[0];
+        const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
+        const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
+        const withdrawalRequestedProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_WITHDRAWALS_REQUESTED_QUERY_PROPS
+                : WITHDRAWALS_REQUESTED_QUERY_PROPS
+            : NEW_WITHDRAWALS_REQUESTED_QUERY_PROPS;
+        const withdrawalProcessedProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_WITHDRAWALS_PROCESSED_QUERY_PROPS
+                : WITHDRAWALS_PROCESSED_QUERY_PROPS
+            : NEW_WITHDRAWALS_PROCESSED_QUERY_PROPS;
+        // Subgraph stores addresses lowercased; only interpolate a validated
+        // address into the query.
+        const receiverWhere = receiver && (0, ethers_1.isAddress)(receiver)
+            ? `where: { receiverAddr: "${receiver.toLowerCase()}" },`
+            : '';
+        const buildQuery = (pageSize, skip) => {
+            // Keep the last-rendered document in the outer `query` so the catch
+            // below can log it on failure.
+            query = `{
+      withdrawalRequesteds(
+        first: ${pageSize},
+        skip: ${skip},
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+        ${receiverWhere}
+      ) {
+        ${withdrawalRequestedProps}
+      }
+      ${noWithdrawalProcessed
+                ? ''
+                : `withdrawalProcesseds (
+        first: ${pageSize},
+        skip: ${skip},
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+        ${receiverWhere}
+      ) {
+        ${withdrawalProcessedProps}
+      }
+      `}
+    }`;
+            return query;
+        };
+        const result = await fetchPagedWithdrawals('getSubgraphAllWithdrawals', goldskyUrl, buildQuery, ['withdrawalRequesteds', 'withdrawalProcesseds']);
+        if (result.status !== 200) {
+            core_1.Logger.log.warn('getSubgraphAllWithdrawals', `${result.statusText}::${result.status}: ${vaultSymbol}::${pool}`);
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphAllWithdrawals',
+                pool,
+                chainId: network,
+                reason: `subgraph returned ${result.status} ${result.statusText}`,
+                slackWebookUrl,
+            });
+            return errorReturnObj;
+        }
+        const requests = {
+            withdrawalRequesteds: result.data
+                .withdrawalRequesteds,
+            withdrawalProcesseds: result.data
+                .withdrawalProcesseds,
+        };
+        return requests;
+    }
+    catch (e) {
+        core_1.Logger.log.error('getSubgraphAllWithdrawals', `${pool}::${e}::${query}`);
+        return {
+            withdrawalRequesteds: [],
+            withdrawalProcesseds: [],
+        };
+    }
+}
+/**
+ * Fetch a user's deposit/withdraw history for an archived vault from the backend
+ * Mongo snapshot (`/upshift/vault_history`) instead of its retired subgraph.
+ *
+ * Returns the same {@link ISubgraphUserHistoryItem} shape as the subgraph path,
+ * so the caller's downstream transform/normalization is unchanged. `amount` is
+ * the raw deposited-asset amount (base units); `decimals` is attached so the
+ * caller can normalize, mirroring the subgraph path.
+ *
+ * Pre-deposit vaults accept multiple deposit assets with differing decimals
+ * (e.g. USDS at 18, USDC at 6). When the backend supplies `asset_address` per
+ * row, it is propagated as {@link ISubgraphUserHistoryItem.assetIn} (and, when
+ * present, `asset_decimals` is used for that row's `decimals`) so lifetime PnL
+ * resolves each deposit against its own token rather than the vault decimals —
+ * without it, an 18-decimal deposit normalized at the vault's 6 decimals
+ * inflates the cost basis by ~1e12. This mirrors the subgraph path, whose
+ * deposit rows already carry `assetIn`.
+ *
+ * Side effects: one RPC read (`getDecimals`) and one HTTP GET to the public API.
+ *
+ * @param user - The wallet whose history to fetch.
+ * @param provider - Contract runner, used to read the vault's decimals.
+ * @param pool - The (archived) vault contract address.
+ * @returns The user's deposits and settled withdrawals. Empty on a non-200
+ *   response.
+ */
+async function getArchivedVaultUserHistory(user, provider, pool) {
+    const decimals = await (0, core_1.getDecimals)(provider, pool);
+    const response = await (0, core_1.fetchUpshiftPublic)(core_1.WEBSERVER_ENDPOINTS.public.tokenizedVault.userHistory(pool, user));
+    if (response.status !== 200) {
+        core_1.Logger.log.error('getArchivedVaultUserHistory', `non-200 from vault_history for ${pool}: ${response.status}`);
+        return [];
+    }
+    const rows = (await response.json());
+    // The backend already stores final ISubgraphUserHistoryItem.type values, so
+    // no translation is needed. Two row-level guards before mapping, since both
+    // bad shapes propagate destructively downstream:
+    //   - amount_raw must be a non-negative integer: the caller does
+    //     BigInt(amount) outside a try/catch, and one bad row would throw and
+    //     wipe the user's entire (all-vault) history.
+    //   - timestamp must parse to a real time: a malformed value makes getTime()
+    //     return NaN, which stringifies to "NaN" and then sorts/normalizes
+    //     incorrectly downstream. Drop the row rather than emit a "NaN" stamp.
+    return (rows
+        .filter((row) => /^\d+$/.test(row.amount_raw) &&
+        !Number.isNaN(new Date(row.timestamp).getTime()))
+        .map((row) => ({
+        id: row.transaction_hash,
+        contractId_: pool,
+        timestamp_: String(Math.floor(new Date(row.timestamp).getTime() / 1000)),
+        transactionHash_: row.transaction_hash,
+        block_number: row.block_number != null ? String(row.block_number) : '0',
+        address: row.wallet,
+        amount: row.amount_raw,
+        type: row.type,
+        // Per-asset decimals when known, else the vault's. PnL re-resolves
+        // decimals from `assetIn` anyway; this keeps display/normalization
+        // correct for any consumer that reads the row's `decimals` directly.
+        decimals: row.asset_decimals ?? decimals,
+        // Carry the deposit asset through so mixed-decimal deposits normalize
+        // against their own token, not the vault's. Omitted when unknown.
+        ...(row.asset_address ? { assetIn: row.asset_address } : {}),
+    }))
+        // Match the subgraph path's ordering contract: sortUserHistory sorts
+        // ascending by unix timestamp_, and downstream consumers rely on that
+        // chronology. The backend returns rows in arbitrary order, so re-sort here.
+        .sort((a, b) => Number(a.timestamp_) - Number(b.timestamp_)));
+}
+async function getSubgraphUserHistory(user, provider, pool, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)()) {
+    try {
+        // This path is EVM-only: it reads chain id and network from an EVM
+        // JsonRpcProvider (eth_chainId / getNetwork) and queries an EVM subgraph.
+        // A non-EVM (Solana / Stellar) vault address routed here would call
+        // eth_chainId against a Solana/Stellar RPC and fail with a 400
+        // ("eth_chainId is not available on SOLANA_MAINNET"). Bail early so non-EVM
+        // vaults are simply skipped rather than throwing on every history fetch.
+        if (!(0, ethers_1.isAddress)(pool)) {
+            return [];
+        }
+        // Archived vaults: serve history from the backend Mongo snapshot instead of
+        // the (retired) subgraph. The archived set is fetched from the backend (the
+        // routing source of truth) so a vault is only rerouted once its history is
+        // backfilled. Same return shape keeps downstream unchanged.
+        const archivedVaults = await (0, fetcher_2.fetchArchivedVaults)();
+        if (archivedVaults.has(pool.toLowerCase())) {
+            return await getArchivedVaultUserHistory(user, provider, pool);
+        }
+        // setup
+        const chainId = await (0, core_1.getChainId)(provider);
+        const requests = [];
+        let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
+        if (vaultSymbol === undefined) {
+            core_1.Logger.log.warn('getSubgraphUserHistory', `cannot find vault symbol for pool: ${pool}`);
+            return requests;
+        }
+        const networkValue = await provider.provider.getNetwork();
+        const network = Number(networkValue.chainId);
+        if (needsMonadSuffix(network, vaultSymbol)) {
+            vaultSymbol = vaultSymbol.concat('_monad');
+        }
+        const noWithdrawalProcessed = vaultSymbol === 'agETH';
+        // sanitize
+        if (vaultSymbol === 'testWETHTSA') {
+            return requests;
+        }
+        const vaultsMetadata = await (0, fetcher_2.fetchVaultMetadata)();
+        const { subgraph } = vaultsMetadata?.[vaultSymbol?.toLowerCase()] || {};
+        const goldskyUrl = subgraph ||
+            core_1.SUBGRAPH_VAULT_URLS[vaultSymbol?.toLowerCase()] ||
+            (0, core_1.getDefaultSubgraphUrl)(networkValue.name, vaultSymbol);
+        if (!goldskyUrl) {
+            core_1.Logger.log.warn('getSubgraphUserHistory', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphUserHistory',
+                pool,
+                chainId,
+                slackWebookUrl,
+            });
+            return requests;
+        }
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool, undefined, false, false))?.[0];
+        const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
+        const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
+        const depositProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_DEPOSIT_QUERY_PROPS
+                : DEPOSIT_QUERY_PROPS
+            : NEW_DEPOSIT_QUERY_PROPS;
+        const withdrawProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_WITHDRAWALS_QUERY_PROPS
+                : WITHDRAWALS_QUERY_PROPS
+            : NEW_WITHDRAWALS_QUERY_PROPS;
+        const withdrawalRequestedProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_WITHDRAWALS_REQUESTED_QUERY_PROPS
+                : WITHDRAWALS_REQUESTED_QUERY_PROPS
+            : NEW_WITHDRAWALS_REQUESTED_QUERY_PROPS;
+        const withdrawalProcessedProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_WITHDRAWALS_PROCESSED_QUERY_PROPS
+                : WITHDRAWALS_PROCESSED_QUERY_PROPS
+            : NEW_WITHDRAWALS_PROCESSED_QUERY_PROPS;
+        // The Deposit filter field must follow the subgraph schema, not the vault
+        // version: the new schema has no `owner` at all (it is `receiverAddr` for
+        // every version, see NEW_DEPOSIT_QUERY_PROPS), so an evm-1 vault on a new
+        // subgraph used to send `where: { owner }` and get a field error → empty
+        // history. Only the old schema differs per version (`owner` on evm-1,
+        // `receiverAddr` on evm-2).
+        const depositFilterField = useOldSchema && version !== 'evm-2' ? 'owner' : 'receiverAddr';
+        const depositQuery = `deposits (
+        first: 1000,
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+        where: { ${depositFilterField}: "${user?.toLowerCase()}" }
+      )  {
+        ${depositProps}
+         }`;
+        const fullRequest = `{
+      withdraws (
+        first: 1000,
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+        where: { receiver: "${user?.toLowerCase()}" }
+      ) {
+          ${withdrawProps}
+      }
+      withdrawalRequesteds (
+        first: 1000,
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+        where: { receiverAddr: "${user?.toLowerCase()}" }
+      ) {
+        ${withdrawalRequestedProps}
+      }
+      ${noWithdrawalProcessed
+            ? ''
+            : `withdrawalProcesseds (
+        first: 1000,
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+        where: { receiverAddr: "${user?.toLowerCase()}" }
+      ) {
+        ${withdrawalProcessedProps}
+      }
+      `}
+      ${depositQuery}
+    }`;
+        const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, fullRequest, GOLDSKY_API_KEY);
+        if (result.status !== 200) {
+            core_1.Logger.log.warn('getSubgraphUserHistory', `${result.statusText}::${result.status}: ${vaultSymbol}::${pool}`);
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphUserHistory',
+                pool,
+                chainId,
+                reason: `subgraph returned ${result.status} ${result.statusText}`,
+                slackWebookUrl,
+            });
+            return requests;
+        }
+        const json = (await result.json());
+        // Format data — vault decimals and per-asset decimals are independent reads.
+        const [decimals, assetDecimals] = await Promise.all([
+            (0, core_1.getDecimals)(provider, pool),
+            buildDepositAssetDecimals(provider, json.data?.deposits),
+        ]);
+        const formattedRequests = sortUserHistory(json.data, chainId, decimals, pool, assetDecimals);
+        return formattedRequests;
+    }
+    catch (e) {
+        core_1.Logger.log.error('getSubgraphUserHistory', `${pool}::${e}`);
+        return [];
+    }
+}
+async function getSubgraphVaultHistory(provider, pool, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)(), opts = {}) {
+    try {
+        // setup
+        const requests = [];
+        let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
+        if (vaultSymbol === undefined) {
+            core_1.Logger.log.warn('getSubgraphVaultHistory', `cannot find vault symbol for pool: ${pool}`);
+            return requests;
+        }
+        const networkValue = await provider.provider.getNetwork();
+        const network = Number(networkValue.chainId);
+        if (needsMonadSuffix(network, vaultSymbol)) {
+            vaultSymbol = vaultSymbol.concat('_monad');
+        } // sanitize
+        if (vaultSymbol === 'testWETHTSA') {
+            return requests;
+        }
+        const vaultsMetadata = await (0, fetcher_2.fetchVaultMetadata)();
+        const { subgraph } = vaultsMetadata?.[vaultSymbol?.toLowerCase()] || {};
+        const goldskyUrl = subgraph ||
+            core_1.SUBGRAPH_VAULT_URLS[vaultSymbol?.toLowerCase()] ||
+            (0, core_1.getDefaultSubgraphUrl)(networkValue.name, vaultSymbol);
+        if (!goldskyUrl) {
+            const chainId = await (0, core_1.getChainId)(provider);
+            core_1.Logger.log.warn('getSubgraphVaultHistory', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphVaultHistory',
+                pool,
+                chainId,
+                slackWebookUrl,
+            });
+            return requests;
+        }
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool, undefined, false, false))?.[0];
+        const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
+        const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
+        const withdrawProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_WITHDRAWALS_QUERY_PROPS
+                : WITHDRAWALS_QUERY_PROPS
+            : NEW_WITHDRAWALS_QUERY_PROPS;
+        const withdrawalRequestedProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_WITHDRAWALS_REQUESTED_QUERY_PROPS
+                : WITHDRAWALS_REQUESTED_QUERY_PROPS
+            : NEW_WITHDRAWALS_REQUESTED_QUERY_PROPS;
+        const withdrawalProcessedProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_WITHDRAWALS_PROCESSED_QUERY_PROPS
+                : WITHDRAWALS_PROCESSED_QUERY_PROPS
+            : NEW_WITHDRAWALS_PROCESSED_QUERY_PROPS;
+        const depositProps = useOldSchema
+            ? version === 'evm-2'
+                ? EVM_V2_DEPOSIT_QUERY_PROPS
+                : DEPOSIT_QUERY_PROPS
+            : NEW_DEPOSIT_QUERY_PROPS;
+        // Each of the four event entities is capped at 1000 rows per request, so
+        // a busy vault would silently truncate. Page all four in lockstep on a
+        // shared `skip` cursor (rows are ordered newest-first) and keep going while
+        // any entity returned a full page. When `sinceTs` is set we can stop early:
+        // once an entity's oldest row in the page predates the window, no later
+        // page can contain in-window rows for it.
+        const PAGE_SIZE = 1000;
+        const accumulated = {
+            withdraws: [],
+            withdrawalRequesteds: [],
+            withdrawalProcesseds: [],
+            deposits: [],
+        };
+        let skip = 0;
+        for (;;) {
+            const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, `{
+      withdraws (
+        first: ${PAGE_SIZE},
+        skip: ${skip},
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+    ) {
+         ${withdrawProps}
+        }
+      withdrawalRequesteds (
+        first: ${PAGE_SIZE},
+        skip: ${skip},
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+      ) {
+        ${withdrawalRequestedProps}
+      }
+      withdrawalProcesseds (
+        first: ${PAGE_SIZE},
+        skip: ${skip},
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+      ) {
+        ${withdrawalProcessedProps}
+      }
+      deposits (
+        first: ${PAGE_SIZE},
+        skip: ${skip},
+        orderBy: ${orderByTimestamp},
+        orderDirection: desc,
+      ) {
+        ${depositProps}
+      }
+    }`, GOLDSKY_API_KEY);
+            if (result.status !== 200) {
+                core_1.Logger.log.warn('getSubgraphVaultHistory', `${result.statusText}::${result.status}: ${vaultSymbol}::${pool}`, { skip });
+                alertMissingSubgraphOnce({
+                    source: 'getSubgraphVaultHistory',
+                    pool,
+                    chainId: network,
+                    reason: `subgraph returned ${result.status} ${result.statusText}`,
+                    slackWebookUrl,
+                });
+                // First page failed → nothing to return. A later page failing still
+                // yields whatever earlier pages accumulated.
+                if (skip === 0)
+                    return requests;
+                break;
+            }
+            const json = (await result.json());
+            const page = json.data;
+            accumulated.withdraws.push(...(page?.withdraws ?? []));
+            accumulated.withdrawalRequesteds.push(...(page?.withdrawalRequesteds ?? []));
+            accumulated.withdrawalProcesseds.push(...(page?.withdrawalProcesseds ?? []));
+            accumulated.deposits.push(...(page?.deposits ?? []));
+            const entities = [
+                page?.withdraws,
+                page?.withdrawalRequesteds,
+                page?.withdrawalProcesseds,
+                page?.deposits,
+            ];
+            const needMore = entities.some((rows) => {
+                if ((rows?.length ?? 0) < PAGE_SIZE)
+                    return false;
+                if (opts.sinceTs === undefined)
+                    return true;
+                const oldest = Number(rows?.[rows.length - 1]?.timestamp_);
+                return !Number.isFinite(oldest) || oldest >= opts.sinceTs;
+            });
+            if (!needMore)
+                break;
+            skip += PAGE_SIZE;
+        }
+        // Format data — vault decimals and per-asset decimals are independent reads.
+        const chainId = await (0, core_1.getChainId)(provider);
+        const [decimals, assetDecimals] = await Promise.all([
+            (0, core_1.getDecimals)(provider, pool),
+            buildDepositAssetDecimals(provider, accumulated?.deposits),
+        ]);
+        const formattedRequests = sortUserHistory(accumulated, chainId, decimals, pool, assetDecimals);
+        return formattedRequests;
+    }
+    catch (e) {
+        core_1.Logger.log.error('getSubgraphVaultHistory', e, { pool });
+        return [];
+    }
+}
+/**
+ * Every transfer of the vault's share token into or out of `user`, oldest
+ * first. Transfers to or from the reward distributors are excluded.
+ *
+ * @param user - Wallet address.
+ * @param provider - EVM provider for the vault's chain.
+ * @param pool - Vault address.
+ * @param slackWebookUrl - Where a missing-subgraph alert is posted.
+ * @param options - `receiptSubgraph: true` reads the vault's receipt-token
+ *   subgraph when the registry has one: evm-2 shares are a separate receipt
+ *   token, which the base subgraph does not index. Falls back to the base
+ *   subgraph, which indexes the shares of vaults that are their own token.
+ * @returns The transfers, or `[]` when the subgraph is missing or the query
+ *   fails.
+ */
+async function getSubgraphUserTransfers(user, provider, pool, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)(), options = {}) {
+    try {
+        // setup
+        let amountOfTransfers = 0;
+        let userTransfers = [];
+        let hasNoData = false;
+        const chainId = await (0, core_1.getChainId)(provider);
+        const walletAddress = user.toLocaleLowerCase();
+        const rewardDistributorAddresses = (0, core_1.REWARD_DISTRIBUTOR_ADDRESS)(chainId).filter((addr) => addr !== '0x0000000000000000000000000000000000000000');
+        let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
+        if (vaultSymbol === undefined) {
+            core_1.Logger.log.warn('getSubgraphUserTransfers', `cannot find vault symbol for pool: ${pool}`);
+            return userTransfers;
+        }
+        const networkValue = await provider.provider.getNetwork();
+        const network = Number(networkValue.chainId);
+        if (needsMonadSuffix(network, vaultSymbol)) {
+            vaultSymbol = vaultSymbol.concat('_monad');
+        } // sanitize
+        if (vaultSymbol === 'testWETHTSA') {
+            return userTransfers;
+        }
+        const vaultsMetadata = await (0, fetcher_2.fetchVaultMetadata)();
+        const { subgraph, receipt_subgraph } = vaultsMetadata?.[vaultSymbol?.toLowerCase()] || {};
+        const goldskyUrl = (options.receiptSubgraph && receipt_subgraph) ||
+            subgraph ||
+            core_1.SUBGRAPH_VAULT_URLS[vaultSymbol?.toLowerCase()] ||
+            (0, core_1.getDefaultSubgraphUrl)(networkValue.name, vaultSymbol);
+        if (!goldskyUrl) {
+            const chainId = await (0, core_1.getChainId)(provider);
+            core_1.Logger.log.warn('getSubgraphUserTransfers', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphUserTransfers',
+                pool,
+                chainId,
+                slackWebookUrl,
+            });
+            return userTransfers;
+        }
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
+        const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
+        const transferProps = useOldSchema
+            ? TRANSFER_QUERY_PROPS
+            : NEW_TRANSFER_QUERY_PROPS;
+        do {
+            // get all the transfers, includes redeem requests and deposits, excludes stake and withdraw events
+            const where = `
+        where: {
+          and: [
+            {
+              or: [
+                {from: "${walletAddress}"},
+                {to: "${walletAddress}"}
+              ]
+            },
+            ${rewardDistributorAddresses.length
+                ? `
+                {
+                  from_not_in: [
+                    ${rewardDistributorAddresses.map((addr) => `"${addr.toLocaleLowerCase()}"`).join(', ')}
+                  ],
+                  to_not_in: [${rewardDistributorAddresses.map((addr) => `"${addr.toLocaleLowerCase()}"`).join(', ')}]
+                }
+              `
+                : ''}
+          ]
+        },
+      `;
+            if (!pool) {
+                throw new Error('Pool address is required for HyperEVM');
+            }
+            const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, `{
+            transfers(
+              first: 1000, skip: ${amountOfTransfers},
+              ${where}
+              orderBy: ${orderByTimestamp}, orderDirection: asc
+            ) {
+              ${transferProps}
+            }
+          }`, GOLDSKY_API_KEY);
+            const json = (await result.json());
+            const { data } = json;
+            userTransfers = [...userTransfers, ...(data?.transfers || [])];
+            amountOfTransfers += data?.transfers?.length || 0;
+            hasNoData = !data?.transfers?.length;
+        } while ((amountOfTransfers === 0 || amountOfTransfers % 1000 === 0) &&
+            !hasNoData);
+        return userTransfers;
+    }
+    catch (e) {
+        core_1.Logger.log.error('getSubgraphUserTransfers', e, { pool });
+        return [];
+    }
+}
+/**
+ * Fetch the `ReserveDeposit` events that minted vault shares to `user`.
+ *
+ * Some vaults mint shares without an ERC-4626 `Deposit` event: High Growth ETH
+ * emits `ReserveDeposit(account, shares, assets)` for deposits made through
+ * Kelp's gain adapter, so {@link getSubgraphUserHistory} never sees them. Its
+ * subgraph indexes the event as `reserveDeposits`.
+ *
+ * Side effects: one `getVaultSymbol` RPC read (cached), the vault metadata and
+ * schema probes (cached), and one subgraph query.
+ *
+ * @param user - The wallet the shares were minted to.
+ * @param provider - Contract runner for the vault's chain.
+ * @param pool - The vault contract address.
+ * @returns Up to 1000 events, oldest first. Empty when the vault's subgraph
+ *   has no `reserveDeposits` entity, has no URL, or the query fails.
+ * @example
+ * ```ts
+ * const reserveDeposits = await getSubgraphUserReserveDeposits(wallet, provider, vault);
+ * ```
+ */
+async function getSubgraphUserReserveDeposits(user, provider, pool) {
+    try {
+        let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
+        if (vaultSymbol === undefined)
+            return [];
+        const networkValue = await provider.provider.getNetwork();
+        if (needsMonadSuffix(Number(networkValue.chainId), vaultSymbol)) {
+            vaultSymbol = vaultSymbol.concat('_monad');
+        }
+        const vaultsMetadata = await (0, fetcher_2.fetchVaultMetadata)();
+        const { subgraph } = vaultsMetadata?.[vaultSymbol.toLowerCase()] || {};
+        const goldskyUrl = subgraph ||
+            core_1.SUBGRAPH_VAULT_URLS[vaultSymbol.toLowerCase()] ||
+            (0, core_1.getDefaultSubgraphUrl)(networkValue.name, vaultSymbol);
+        if (!goldskyUrl)
+            return [];
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
+        const props = useOldSchema
+            ? 'id account shares assets transactionHash_ timestamp_ block_number'
+            : 'id account shares assets transactionHash_: transactionHash timestamp_: blockTimestamp block_number: blockNumber';
+        const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, `{
+        reserveDeposits(
+          first: 1000,
+          orderBy: ${useOldSchema ? 'timestamp_' : 'blockTimestamp'},
+          orderDirection: asc,
+          where: { account: "${user.toLowerCase()}" }
+        ) {
+          ${props}
+        }
+      }`, GOLDSKY_API_KEY);
+        if (result.status !== 200)
+            return [];
+        const json = (await result.json());
+        if (json.errors?.length && !(0, schema_1.isSubgraphSchemaFieldError)(json.errors)) {
+            core_1.Logger.log.warn('getSubgraphUserReserveDeposits', `${pool}::${JSON.stringify(json.errors).slice(0, 200)}`);
+        }
+        return json.data?.reserveDeposits ?? [];
+    }
+    catch (e) {
+        core_1.Logger.log.warn('getSubgraphUserReserveDeposits', `${pool}::${e}`);
+        return [];
+    }
+}
+//# sourceMappingURL=vaults.js.map