@upshiftfinance/sdk 0.0.0-stage → 0.2.0

package/lib/modules/vaults/fetcher.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVaultMetadata = void 0;
+exports.fetchArchivedVaults = fetchArchivedVaults;
+exports.isArchivedVault = isArchivedVault;
+exports.fetchVaultWithFallback = fetchVaultWithFallback;
+exports.fetchVaultsBatch = fetchVaultsBatch;
+exports.fetchVaultsComprehensive = fetchVaultsComprehensive;
+exports.filterVaultsIntelligently = filterVaultsIntelligently;
+const core_1 = require("../../core");
+const concurrency_1 = require("../../core/helpers/concurrency");
+const ARCHIVED_VAULTS_CACHE_KEY = 'archived_vaults';
+const ARCHIVED_VAULTS_TTL_MS = 10 * 60 * 1000;
+/**
+ * Fetch the set of vaults whose deposit/withdraw history is served from the
+ * backend Mongo snapshot (`/upshift/vault_history`) rather than their (retired)
+ * Goldsky subgraph.
+ *
+ * This is the routing source of truth: a vault appears here only once its
+ * history has been backfilled, so the SDK can never reroute a vault to empty
+ * snapshot data ahead of its backfill. Result is cached for 10 minutes.
+ *
+ * Side effects: one HTTP GET to the public API (cached).
+ *
+ * @returns A set of lowercased vault addresses. Empty on any error — callers
+ *   then fall back to the subgraph path, which is the safe default while
+ *   subgraphs still exist.
+ */
+async function fetchArchivedVaults() {
+    const cached = core_1.CACHE.get(ARCHIVED_VAULTS_CACHE_KEY);
+    if (cached)
+        return cached;
+    try {
+        const response = await (0, core_1.fetchUpshiftPublic)(core_1.WEBSERVER_ENDPOINTS.public.tokenizedVault.archivedVaults);
+        if (response.status !== 200) {
+            core_1.Logger.log.error('fetchArchivedVaults', `non-200 from archived endpoint: ${response.status}`);
+            return new Set();
+        }
+        const addresses = (await response.json());
+        const set = new Set(addresses.map((a) => a.toLowerCase()));
+        core_1.CACHE.set(ARCHIVED_VAULTS_CACHE_KEY, set, { ttl: ARCHIVED_VAULTS_TTL_MS });
+        return set;
+    }
+    catch (e) {
+        core_1.Logger.log.error('fetchArchivedVaults', e);
+        return new Set();
+    }
+}
+/**
+ * Whether a vault's history should be served from the backend snapshot rather
+ * than its subgraph. Backed by {@link fetchArchivedVaults} (cached).
+ *
+ * @param vaultAddress - The vault contract address (any casing).
+ * @returns `true` if the vault has a backfilled history snapshot.
+ */
+async function isArchivedVault(vaultAddress) {
+    const archived = await fetchArchivedVaults();
+    return archived.has(vaultAddress.toLowerCase());
+}
+/** @internal */
+async function runWithConcurrency(tasks, limit) {
+    if (!Number.isFinite(limit) || limit <= 0) {
+        throw new Error(`runWithConcurrency: limit must be a positive finite number, got ${limit}`);
+    }
+    const results = new Array(tasks.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(Math.floor(limit), tasks.length);
+    // `nextIndex++` is safe across workers — JS is single-threaded and the
+    // increment runs to completion before any worker yields at `await`.
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const i = nextIndex++;
+            if (i >= tasks.length)
+                return;
+            results[i] = await tasks[i]();
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+/**
+ * Specialized vault fetching with enhanced retry logic and fallback strategies
+ * This function attempts to fetch vault data with multiple fallback approaches
+ *
+ * The return shape is "success flag wins": when `success === true`, `data` is
+ * the resolved value (which may legitimately be falsy — `0`, `''`, `0n`,
+ * `null`); when `success === false`, `error` is populated. Callers must branch
+ * on `success`, not on the truthiness of `data`.
+ */
+async function fetchVaultWithFallback(vaultAddress, fetchFn, options = {}) {
+    const { maxRetries = 3, baseDelay = 1000 } = options;
+    try {
+        const data = await (0, core_1.withRetry)(fetchFn, maxRetries * 2, baseDelay * 2);
+        return { success: true, data, strategy: 'extended-retry' };
+    }
+    catch (error) {
+        core_1.Logger.log.warn('fetchVaultWithFallback:extended_retry_failed', {
+            vault: vaultAddress,
+            error,
+        });
+    }
+    return {
+        success: false,
+        error: new Error(`All strategies failed for vault ${vaultAddress}`),
+        strategy: 'all-failed',
+    };
+}
+/**
+ * Batch vault fetching with intelligent retry and fallback
+ * Ensures maximum vault coverage by trying multiple strategies
+ */
+async function fetchVaultsBatch(vaults, options = {}) {
+    const { maxRetries = 3, baseDelay = 1000, batchSize = 10, parallelLimit = batchSize, } = options;
+    const successful = [];
+    const failed = [];
+    let totalAttempted = 0;
+    for (let i = 0; i < vaults.length; i += batchSize) {
+        const batch = vaults.slice(i, i + batchSize);
+        const batchTasks = batch.map((vault, batchIndex) => async () => {
+            const globalIndex = i + batchIndex;
+            totalAttempted++;
+            try {
+                const result = await fetchVaultWithFallback(vault.address, vault.fetchFn, {
+                    maxRetries,
+                    baseDelay,
+                });
+                // Branch on `result.success` only — not on truthiness of `result.data`.
+                // A successful fetch can legitimately resolve to a falsy value
+                // (`0`, `''`, `0n`, `null`); the cast respects the function's
+                // documented contract that `data` is present on the success branch.
+                if (result.success) {
+                    successful.push({
+                        index: globalIndex,
+                        data: result.data,
+                        strategy: result.strategy,
+                    });
+                }
+                else {
+                    failed.push({
+                        index: globalIndex,
+                        error: result.error ?? new Error('Unknown failure'),
+                        address: vault.address,
+                    });
+                }
+            }
+            catch (error) {
+                failed.push({
+                    index: globalIndex,
+                    error: error,
+                    address: vault.address,
+                });
+            }
+        });
+        await runWithConcurrency(batchTasks, parallelLimit);
+        // Small delay between batches to be respectful to RPC endpoints
+        if (i + batchSize < vaults.length) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    const successRate = totalAttempted > 0 ? (successful.length / totalAttempted) * 100 : 0;
+    return {
+        successful,
+        failed,
+        totalAttempted,
+        successRate,
+    };
+}
+/**
+ * Comprehensive vault fetching that handles all failure points
+ * This function ensures maximum vault coverage by implementing multiple strategies
+ */
+async function fetchVaultsComprehensive(vaults, fetchFn, options = {}) {
+    const { maxRetries = 5, baseDelay = 2000, batchSize = 10, parallelLimit = batchSize, includeClosed: _includeClosed = false, // Reserved for future filtering
+    includeInvisible: _includeInvisible = false, // Reserved for future filtering
+    fallbackRpcUrls = {}, timeout = 60000, } = options;
+    const successful = [];
+    const failed = [];
+    const rpcFailures = {};
+    let totalAttempted = 0;
+    for (let i = 0; i < vaults.length; i += batchSize) {
+        const batch = vaults.slice(i, i + batchSize);
+        const batchTasks = batch.map((vault, batchIndex) => async () => {
+            const globalIndex = i + batchIndex;
+            totalAttempted++;
+            let attempts = 0;
+            let lastError;
+            // Strategy 1: Primary fetch with retry
+            for (attempts = 1; attempts <= maxRetries; attempts++) {
+                try {
+                    const data = await (0, concurrency_1.withTimeout)(fetchFn(vault), timeout, 'Primary fetch');
+                    successful.push({
+                        index: globalIndex,
+                        data,
+                        strategy: 'primary-retry',
+                        attempts,
+                    });
+                    return;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (attempts < maxRetries) {
+                        const delay = baseDelay * 2 ** (attempts - 1);
+                        core_1.Logger.log.warn('fetchVaultsComprehensive', `Vault ${vault.address} attempt ${attempts} failed, retrying in ${delay}ms: ${error.message}`);
+                        await new Promise((resolve) => setTimeout(resolve, delay));
+                    }
+                }
+            }
+            // Strategy 2: Try with fallback RPC endpoints
+            if (fallbackRpcUrls[vault.chain] &&
+                fallbackRpcUrls[vault.chain].length > 0) {
+                for (const fallbackRpc of fallbackRpcUrls[vault.chain]) {
+                    try {
+                        const data = await (0, concurrency_1.withTimeout)(fetchFn({ ...vault, fallbackRpc }), timeout, 'Fallback RPC');
+                        successful.push({
+                            index: globalIndex,
+                            data,
+                            strategy: 'fallback-rpc',
+                            attempts: attempts + 1,
+                        });
+                        return;
+                    }
+                    catch (error) {
+                        core_1.Logger.log.warn('fetchVault:fallback_rpc_failed', {
+                            vault: vault.address,
+                            fallbackRpc,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+            }
+            // Strategy 3: Try with minimal data fetching (if fetchFn supports it)
+            try {
+                const data = await (0, concurrency_1.withTimeout)(fetchFn({ ...vault, minimal: true }), timeout, 'Minimal fetch');
+                successful.push({
+                    index: globalIndex,
+                    data,
+                    strategy: 'minimal-data',
+                    attempts: attempts + 1,
+                });
+                return;
+            }
+            catch (error) {
+                core_1.Logger.log.warn('fetchVault:minimal_data_failed', {
+                    vault: vault.address,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            // Strategy 4: Extended retry with longer delays
+            try {
+                const extendedDelay = baseDelay * 3;
+                await new Promise((resolve) => setTimeout(resolve, extendedDelay));
+                const data = await (0, concurrency_1.withTimeout)(fetchFn(vault), timeout, 'Extended retry');
+                successful.push({
+                    index: globalIndex,
+                    data,
+                    strategy: 'extended-retry',
+                    attempts: attempts + 2,
+                });
+                return;
+            }
+            catch (error) {
+                core_1.Logger.log.warn('fetchVault:extended_retry_failed', {
+                    vault: vault.address,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            // All strategies failed
+            failed.push({
+                index: globalIndex,
+                error: lastError || new Error('All strategies failed'),
+                address: vault.address,
+                chain: vault.chain,
+                attempts: attempts + 2,
+            });
+            // Track RPC failures by chain
+            rpcFailures[vault.chain] = (rpcFailures[vault.chain] || 0) + 1;
+        });
+        await runWithConcurrency(batchTasks, parallelLimit);
+        // Small delay between batches to be respectful to RPC endpoints
+        if (i + batchSize < vaults.length) {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+    }
+    const successRate = totalAttempted > 0 ? (successful.length / totalAttempted) * 100 : 0;
+    return {
+        successful,
+        failed,
+        totalAttempted,
+        successRate,
+        coverageReport: {
+            totalVaults: vaults.length,
+            successfulVaults: successful.length,
+            failedVaults: failed.length,
+            closedVaults: 0, // Will be calculated by the calling code
+            invisibleVaults: 0, // Will be calculated by the calling code
+            rpcFailures,
+        },
+    };
+}
+/**
+ * Enhanced vault filtering that preserves more vaults while maintaining quality
+ */
+function filterVaultsIntelligently(vaults, options = {}) {
+    const { includeClosed = true, includeInvisible = true, includeNull = false, minStatus = ['active', 'closed'], } = options;
+    const active = [];
+    const closed = [];
+    const invisible = [];
+    const failed = [];
+    vaults.forEach((vault, index) => {
+        if (!vault) {
+            if (includeNull) {
+                failed.push({ index, reason: 'null_response' });
+            }
+            return;
+        }
+        const status = vault.status || 'unknown';
+        const isVisible = vault.isVisible ?? vault.is_visible ?? true;
+        if (status === 'active' && isVisible) {
+            active.push(vault);
+        }
+        else if (status === 'closed' && includeClosed) {
+            closed.push(vault);
+        }
+        else if (!isVisible && includeInvisible) {
+            invisible.push(vault);
+        }
+        else if (minStatus.includes(status)) {
+            active.push(vault);
+        }
+        else {
+            failed.push({
+                index,
+                reason: `status_${status}_invisible_${!isVisible}`,
+            });
+        }
+    });
+    const total = vaults.length;
+    const successCount = active.length + closed.length + invisible.length;
+    const successRate = total > 0 ? (successCount / total) * 100 : 0;
+    return {
+        active,
+        closed,
+        invisible,
+        failed,
+        summary: {
+            total,
+            active: active.length,
+            closed: closed.length,
+            invisible: invisible.length,
+            failed: failed.length,
+            successRate,
+        },
+    };
+}
+var vault_metadata_1 = require("../../core/vault-metadata");
+Object.defineProperty(exports, "fetchVaultMetadata", { enumerable: true, get: function () { return vault_metadata_1.fetchVaultMetadata; } });
+//# sourceMappingURL=fetcher.js.map