@augustdigital/sdk 8.5.0 → 8.6.1

package/lib/core/helpers/chain-error.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUserRejectionError = isUserRejectionError;
+exports.isExpectedRevertError = isExpectedRevertError;
+exports.logChainError = logChainError;
+const logger_1 = require("../logger");
+/**
+ * Classification of caught chain/RPC/wallet errors so the SDK can decide
+ * whether a failure is worth a standalone Sentry issue or is routine, expected
+ * noise that should ride along as a breadcrumb instead.
+ *
+ * Why this exists: most of the SDK's read/write paths `catch` and re-throw, and
+ * historically logged every caught error at `error` level — which the SDK's
+ * Sentry sink turns into a billed issue (see the severity policy on
+ * `SDKSentrySink` in `core/logger`). Two large, low-signal categories dominate
+ * that volume:
+ *
+ * 1. **User-rejected transactions** — the user clicked "reject" in their wallet.
+ *    This is normal product behaviour, not an SDK fault, yet it fires on every
+ *    cancelled deposit/redeem/approve.
+ * 2. **Expected on-chain read reverts** — reading a function a vault doesn't
+ *    implement, or an address with no/incompatible bytecode, reverts. This is a
+ *    routine outcome of probing heterogeneous vaults, not a defect.
+ *
+ * These predicates let call sites demote exactly those cases to `warn` while
+ * leaving genuine failures at `error`. They are intentionally dependency-free
+ * (no `ethers`/Sentry imports) so they stay cheap and safe in both browser and
+ * Node, and classify purely by inspecting the error's `code`/`message` shape.
+ *
+ * @module
+ */
+/**
+ * Best-effort message extraction from an unknown thrown value. Reads
+ * `error.message` for `Error` and error-like objects, passes strings through,
+ * and falls back to `String(error)` for everything else. Never throws.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns The error's message text (never `undefined`).
+ */
+function errorText(error) {
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    if (error && typeof error === 'object') {
+        const maybe = error.message;
+        if (typeof maybe === 'string')
+            return maybe;
+    }
+    return String(error);
+}
+/**
+ * Collect the `code` fields an error-like value may carry. Wallet/provider
+ * errors stash their machine-readable code in different places depending on the
+ * stack: ethers sets a top-level string `code` (e.g. `'ACTION_REJECTED'`),
+ * EIP-1193 providers use a numeric `code` (e.g. `4001`), and some wrap the
+ * original under `error`/`info.error`/`cause`. We scan the common locations so
+ * callers needn't know which library produced the error.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns Every string/number `code` found (possibly empty).
+ */
+function errorCodes(error) {
+    const codes = [];
+    if (error && typeof error === 'object') {
+        const e = error;
+        const candidates = [
+            e.code,
+            e.error?.code,
+            e.info?.error?.code,
+            e.cause?.code,
+        ];
+        for (const c of candidates) {
+            if (typeof c === 'string' || typeof c === 'number')
+                codes.push(c);
+        }
+    }
+    return codes;
+}
+/**
+ * Is this error a wallet/user rejection of a transaction or signature request?
+ *
+ * Detects ethers v6's `ACTION_REJECTED` code, the EIP-1193 `4001`
+ * ("User rejected the request") code (top-level or nested), and the common
+ * human-readable phrasings as a fallback for providers that omit a code.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure was the user declining in their wallet.
+ *
+ * @example
+ * ```ts
+ * try { await vault.deposit(...); }
+ * catch (e) {
+ *   if (isUserRejectionError(e)) return; // user cancelled — not an error
+ *   throw e;
+ * }
+ * ```
+ */
+function isUserRejectionError(error) {
+    const codes = errorCodes(error);
+    if (codes.includes('ACTION_REJECTED') || codes.includes(4001))
+        return true;
+    const msg = errorText(error).toLowerCase();
+    return (msg.includes('user rejected') ||
+        msg.includes('user denied') ||
+        msg.includes('rejected the request') ||
+        msg.includes('request rejected'));
+}
+/**
+ * Is this error a routine on-chain read revert rather than a real failure?
+ *
+ * Reading a function a contract doesn't implement, or an address that holds no
+ * (or incompatible) bytecode, reverts — a normal outcome when the SDK probes
+ * heterogeneous vaults. Matches ethers' `CALL_EXCEPTION` code and the
+ * message variants emitted by ethers and viem (`missing revert data`,
+ * `execution reverted`, `call revert exception`, and the bare `reverted`
+ * phrasing such as `the contract function "totalAssets" reverted`).
+ *
+ * Scope note: callers apply this on **read** paths only. A reverted *write*
+ * (a tx that failed on-chain) is a genuine error and is intentionally not
+ * demoted by this predicate's use in `write.actions`.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure is an expected/benign contract revert.
+ *
+ * @example
+ * ```ts
+ * try { return await vaultContract.maxDepositAmount(); }
+ * catch (e) {
+ *   logChainError('maxDeposit', e, isExpectedRevertError(e));
+ *   throw e;
+ * }
+ * ```
+ */
+function isExpectedRevertError(error) {
+    const codes = errorCodes(error);
+    if (codes.includes('CALL_EXCEPTION'))
+        return true;
+    const msg = errorText(error).toLowerCase();
+    return (msg.includes('call_exception') ||
+        msg.includes('missing revert data') ||
+        msg.includes('execution reverted') ||
+        msg.includes('call revert exception') ||
+        msg.includes('reverted'));
+}
+/**
+ * Log a caught chain error at the severity its category warrants, without
+ * swallowing it. When `isBenign` is `true` the failure is recorded as a `warn`
+ * (a Sentry breadcrumb that rides along with the next real issue, not a billed
+ * standalone issue); otherwise it is logged at `error` (a Sentry issue). The
+ * caller is still responsible for re-throwing — this only routes telemetry.
+ *
+ * Pass the benign decision explicitly (via {@link isUserRejectionError} or
+ * {@link isExpectedRevertError}) so the call site documents *why* the demotion
+ * is safe and each path opts into only the category that applies to it.
+ *
+ * @param tag - Low-cardinality call-site label (e.g. `'deposit'`), used as the
+ *   Sentry breadcrumb/issue grouping key.
+ * @param error - The caught value, of unknown type.
+ * @param isBenign - `true` to demote to `warn`; `false` to keep at `error`.
+ * @param context - Optional structured context attached to the log entry. It is
+ *   sanitized by the logger before transport.
+ */
+function logChainError(tag, error, isBenign, context) {
+    if (isBenign) {
+        // Demote to a breadcrumb: the SDK's Sentry sink forwards `warn` as a
+        // breadcrumb, so this no longer creates its own billed issue while still
+        // preserving the trail if a genuine error follows.
+        logger_1.Logger.log.warn(tag, { message: errorText(error), ...(context ?? {}) });
+        return;
+    }
+    logger_1.Logger.log.error(tag, error, context);
+}
+//# sourceMappingURL=chain-error.js.map

package/lib/core/helpers/core.d.ts

@@ -18,12 +18,13 @@ export declare const filterOutBySize: (usdAmount: number) => boolean;
 export declare function toTitleCase(str: string, type?: 'camel'): string;
 export declare function truncate(s: string, amount?: number): string;
 /**
- * @function round formats any type number value to a standard
+ * Formats any numeric value (number, string, or bigint) to a standardized string.
  *
- * @param value amount to be formatted
- * @param options.showing amount of decimals to cut off at
- * @param options.usd if wanting to display USD value
- * @param options.decimals if passing type bigint, how many decimals to parse to
+ * @param value - amount to be formatted
+ * @param options - formatting options:
+ *   `showing` is the number of decimals to cut off at (or `'all'`);
+ *   `usd` toggles USD-value display;
+ *   `decimals` is how many decimals to parse to when `value` is a bigint.
  *
  * @returns standardized string type value
  */
@@ -44,22 +45,24 @@ export declare function prepareDateForDb(date: string | Date): string;
 /**
  * Arrays
  */
-export declare function orderObjArrByDate(objectArray: any[], options?: {
+export declare function orderObjArrByDate<T extends Record<string, unknown>>(objectArray: T[], options?: {
     key?: string;
     order?: 'asc' | 'desc';
-}): any[];
+}): T[];
 /**
- * Calculate weights based on a specific property in array of objects
- * @param {Array<Object>} data - Array of objects to calculate weights for
- * @param {string} weightProperty - Property name to base weights on
- * @returns {Array<Object>} Original data with weights added
+ * Calculate weights based on a specific property in array of objects.
+ * @param data - Array of objects to calculate weights for
+ * @param weightProperty - Property name to base weights on
+ * @returns Original data with each item's `weight` added
  */
-export declare function calculateWeights(data?: Array<any>, weightProperty?: string): any[];
+export declare function calculateWeights<T extends Record<string, unknown>>(data?: T[], weightProperty?: string): Array<T & {
+    weight: number;
+}>;
 /**
- * Calculate weighted average for array of objects
- * @param {Array<Object>} data - Array of objects with values
- * @param {string} valueProperty - Property name containing the value to average
- * @param {string} [weightProperty] - Optional property to base weights on
- * @returns {number} Weighted average
+ * Calculate weighted average for array of objects.
+ * @param data - Array of objects with values
+ * @param valueProperty - Property name containing the value to average
+ * @param weightProperty - Optional property to base weights on
+ * @returns Weighted average
  */
-export declare function calculateWeightedAverage(data?: Array<any>, valueProperty?: string, weightProperty?: string): any;
+export declare function calculateWeightedAverage<T extends Record<string, unknown>>(data?: T[], valueProperty?: string, weightProperty?: string): number;

package/lib/core/helpers/core.js

@@ -67,7 +67,7 @@ function toNormalizedBn(value, decimals = 18) {
 function getFallbackRpcUrls(chainId) {
     return web3_1.FALLBACK_RPC_URLS[chainId] || [];
 }
-const filterOutBySize = (usdAmount) => usdAmount > 3000;
+const filterOutBySize = (usdAmount) => usdAmount > 3_000;
 exports.filterOutBySize = filterOutBySize;
 /**
  * Formatters
@@ -120,12 +120,13 @@ function truncate(s, amount) {
     return `${s.slice(0, amount ? amount : 4)}...${s.slice(amount ? amount * -1 : -4)}`;
 }
 /**
- * @function round formats any type number value to a standard
+ * Formats any numeric value (number, string, or bigint) to a standardized string.
  *
- * @param value amount to be formatted
- * @param options.showing amount of decimals to cut off at
- * @param options.usd if wanting to display USD value
- * @param options.decimals if passing type bigint, how many decimals to parse to
+ * @param value - amount to be formatted
+ * @param options - formatting options:
+ *   `showing` is the number of decimals to cut off at (or `'all'`);
+ *   `usd` toggles USD-value display;
+ *   `decimals` is how many decimals to parse to when `value` is a bigint.
  *
  * @returns standardized string type value
  */
@@ -133,7 +134,7 @@ function round(value, options) {
     // standardize to string
     let _value;
     if (typeof value === 'bigint') {
-        _value = toNormalizedBn(value, options.decimals ?? web3_1.FALLBACK_DECIMALS).normalized;
+        _value = toNormalizedBn(value, options?.decimals ?? web3_1.FALLBACK_DECIMALS).normalized;
     }
     else {
         _value = String(value);
@@ -202,7 +203,7 @@ function loanStateToReadable(loanState) {
  */
 function dateToUnix(date) {
     if (!date)
-        return Math.floor(new Date().getTime());
+        return Math.floor(Date.now());
     return Math.floor(new Date(date).getTime());
 }
 function unixToDate(epoch) {
@@ -230,19 +231,20 @@ function prepareDateForDb(date) {
 function orderObjArrByDate(objectArray, options) {
     const selectedOrder = options?.order ?? 'desc';
     const selectedKey = options?.key ?? 'date';
+    const toTime = (item) => new Date(item[selectedKey]).valueOf();
     return objectArray.sort((a, b) => {
         // Turn your strings into dates, and then subtract them
         // to get a value that is either negative, positive, or zero.
         if (selectedOrder === 'asc')
-            return (new Date(a[selectedKey]).valueOf() - new Date(b[selectedKey]).valueOf());
-        return (new Date(b[selectedKey]).valueOf() - new Date(a[selectedKey]).valueOf());
+            return toTime(a) - toTime(b);
+        return toTime(b) - toTime(a);
     });
 }
 /**
- * Calculate weights based on a specific property in array of objects
- * @param {Array<Object>} data - Array of objects to calculate weights for
- * @param {string} weightProperty - Property name to base weights on
- * @returns {Array<Object>} Original data with weights added
+ * Calculate weights based on a specific property in array of objects.
+ * @param data - Array of objects to calculate weights for
+ * @param weightProperty - Property name to base weights on
+ * @returns Original data with each item's `weight` added
  */
 function calculateWeights(data, weightProperty) {
     if (!data || data.length === 0 || !weightProperty)
@@ -256,16 +258,16 @@ function calculateWeights(data, weightProperty) {
     }));
 }
 /**
- * Calculate weighted average for array of objects
- * @param {Array<Object>} data - Array of objects with values
- * @param {string} valueProperty - Property name containing the value to average
- * @param {string} [weightProperty] - Optional property to base weights on
- * @returns {number} Weighted average
+ * Calculate weighted average for array of objects.
+ * @param data - Array of objects with values
+ * @param valueProperty - Property name containing the value to average
+ * @param weightProperty - Optional property to base weights on
+ * @returns Weighted average
  */
 function calculateWeightedAverage(data, valueProperty, weightProperty) {
     if (!data || data.length === 0 || !valueProperty)
         return 0;
-    let weightedData = data;
+    let weightedData;
     // If no weightProperty specified, use equal weights
     if (!weightProperty) {
         weightedData = data.map((item) => ({

package/lib/core/helpers/explorer-link.d.ts

@@ -1,4 +1,4 @@
-import { IAddress, IChainId, IExplorerType } from '../../types';
+import type { IAddress, IChainId, IExplorerType } from '../../types';
 /**
  * Generate a block-explorer URL for an address or transaction hash.
  *

package/lib/core/helpers/signer.d.ts

@@ -1,4 +1,4 @@
-import { Signer, Wallet } from 'ethers';
+import { type Signer, type Wallet } from 'ethers';
 /**
  * Signer Compatibility Helpers
  *

package/lib/core/helpers/swap-router.d.ts

@@ -1,4 +1,4 @@
-import { IAddress } from '../../types';
+import type { IAddress } from '../../types';
 /**
  * Resolve the `SwapRouter` address for a chain.
  *

package/lib/core/helpers/vault-version.d.ts

@@ -1,4 +1,4 @@
-import { ITokenizedVault, IVaultVersion, ChainType } from '../../types';
+import type { ITokenizedVault, IVaultVersion, ChainType } from '../../types';
 /** Classify an address by chain family (evm / solana / stellar / sui). */
 export declare function getAddressChainType(address: string): ChainType;
 export declare function getVaultVersion(vault: string): IVaultVersion | undefined;

package/lib/core/helpers/vaults.d.ts

@@ -1,4 +1,4 @@
-import { IAddress, IContractRunner } from '../../types';
+import type { IAddress, IContractRunner } from '../../types';
 /**
  * Bad transactions that should be ignored
  * these transactions are usually from tests and can skew data

package/lib/core/helpers/web3.d.ts

@@ -1,7 +1,7 @@
-import { ethers, Interface, InterfaceAbi, JsonRpcProvider } from 'ethers';
+import { ethers, Interface, type InterfaceAbi, JsonRpcProvider } from 'ethers';
 import type { Abi } from 'abitype';
 import type { TypedContract } from '../../types/typed-contract';
-import { IAddress, IContractRunner, IInfuraOptions } from '../../types';
+import type { IAddress, IContractRunner, IInfuraOptions } from '../../types';
 /**
  * Web3 Helper Utilities
  *

package/lib/core/helpers/web3.js

@@ -41,13 +41,13 @@ const vault_version_1 = require("./vault-version");
 const determineBlockCutoff = (chain) => {
     switch (chain) {
         case 56:
-            return 120000;
+            return 120_000;
         case 43114:
-            return 120000;
+            return 120_000;
         case 143:
-            return 3456000;
+            return 3_456_000;
         default:
-            return 150000;
+            return 150_000;
     }
 };
 exports.determineBlockCutoff = determineBlockCutoff;
@@ -78,15 +78,15 @@ exports.determineSecondsPerBlock = determineSecondsPerBlock;
 const determineBlockSkipInternal = (chain) => {
     switch (chain) {
         case 43114:
-            return 8000;
+            return 8_000;
         case 56:
-            return 8000;
+            return 8_000;
         case 143: // Monad — Alchemy limits eth_getLogs to 1000 blocks
-            return 1000;
+            return 1_000;
         case 999: // HyperEVM — rpc.hypurrscan.io limits eth_getLogs to 1000 blocks
-            return 1000;
+            return 1_000;
         default:
-            return 50000;
+            return 50_000;
     }
 };
 exports.determineBlockSkipInternal = determineBlockSkipInternal;

package/lib/core/index.d.ts

@@ -12,6 +12,7 @@ export * from './constants/vaults';
 export * from './constants/swap-router';
 export * from './helpers/web3';
 export * from './helpers/vaults';
+export * from './helpers/chain-error';
 export * from './helpers/core';
 export * from './helpers/adapters';
 export * from './helpers/signer';

package/lib/core/index.js

@@ -28,6 +28,7 @@ __exportStar(require("./constants/vaults"), exports);
 __exportStar(require("./constants/swap-router"), exports);
 __exportStar(require("./helpers/web3"), exports);
 __exportStar(require("./helpers/vaults"), exports);
+__exportStar(require("./helpers/chain-error"), exports);
 __exportStar(require("./helpers/core"), exports);
 __exportStar(require("./helpers/adapters"), exports);
 __exportStar(require("./helpers/signer"), exports);

package/lib/core/vault-metadata.d.ts

@@ -1,4 +1,4 @@
-import { IVaultMetadata } from '../types';
+import type { IVaultMetadata } from '../types';
 /**
  * Fetch vault metadata from the upshift API.
  * Returns metadata including symbol, subgraph URL, and address for all vaults.

package/lib/core/version-check.js

@@ -30,7 +30,7 @@ let hasRunCheck = false;
 const NPM_PACKAGE = '@augustdigital/sdk';
 const REGISTRY_URL = `https://registry.npmjs.org/${NPM_PACKAGE}/latest`;
 /** Timeout for the registry request. 5s is generous; faster failures stay silent. */
-const REQUEST_TIMEOUT_MS = 5000;
+const REQUEST_TIMEOUT_MS = 5_000;
 /**
  * Read the current installed SDK version from the generated `version.ts`
  * shim. Returns `null` when running from source (the file is gitignored and

package/lib/evm/methods/crossChainVault.js

@@ -90,7 +90,7 @@ const DEFAULT_HUB_LZ_COMPOSE_GAS_LIMIT = 2000000n;
 // serialize patched calls. The timeout THROWS rather than silently racing
 // concurrent callers' patches.
 // ---------------------------------------------------------------------------
-const PATCH_LOCK_TIMEOUT_MS = 30000;
+const PATCH_LOCK_TIMEOUT_MS = 30_000;
 let patchLock = Promise.resolve();
 // ---------------------------------------------------------------------------
 // Internal helpers

package/lib/evm/types/crossChain.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CROSS_CHAIN_QUOTE_TTL_MS = void 0;
 exports.isQuoteStale = isQuoteStale;
 /** Default validity window for a cross-chain quote (30s). */
-exports.CROSS_CHAIN_QUOTE_TTL_MS = 30000;
+exports.CROSS_CHAIN_QUOTE_TTL_MS = 30_000;
 /** Returns `true` when the quote should be refreshed before submitting. */
 function isQuoteStale(quote, now = Date.now()) {
     return now >= quote.expiresAt;

package/lib/main.d.ts

@@ -69,7 +69,7 @@ export declare class AugustSDK extends AugustBase {
      * @param symbol - Token symbol or contract address
      * @returns Current price in USD
      */
-    getPrice(symbol: string): Promise<any>;
+    getPrice(symbol: string): Promise<number>;
     /**
      * Vault Data and Operations
      */

package/lib/main.js

@@ -56,6 +56,13 @@ const api_1 = require("./modules/api");
  * Provides unified access to EVM, Solana, Sui, and Stellar blockchain adapters.
  */
 class AugustSDK extends core_1.AugustBase {
+    vaults;
+    subaccounts;
+    api;
+    solana;
+    sui;
+    stellar;
+    evm;
     /**
      * Initialize the August SDK with provider configuration.
      * Automatically sets up EVM adapter and optionally initializes Solana if RPC URL is provided.

package/lib/modules/sub-accounts/fetcher.d.ts

@@ -1,5 +1,5 @@
-import { IFetchAugustOptions } from '../../core';
-import { IAddress, IOTCPosition, IWSSubaccountCefi, IWSSubAccountHealthFactor, IWSSubaccountLoan, IWSSubaccountSummary } from '../../types';
+import { type IFetchAugustOptions } from '../../core';
+import type { IAddress, IOTCPosition, IWSSubaccountCefi, IWSSubAccountHealthFactor, IWSSubaccountLoan, IWSSubaccountSummary } from '../../types';
 /**
  * Fetch subaccount health factor for a given subaccount address
  */

package/lib/modules/sub-accounts/main.d.ts

@@ -1,5 +1,5 @@
-import { AugustBase, IAugustBase } from '../../core';
-import { IAddress } from '../../types';
+import { AugustBase, type IAugustBase } from '../../core';
+import type { IAddress } from '../../types';
 /**
  * Subaccount operation class interacting with August Subaccounts
  * Subaccount is a smart contract wallet that serves as the fundamental infrastructure for August's platform.

package/lib/modules/sub-accounts/main.js

@@ -16,9 +16,9 @@ const core_1 = require("../../core");
  * Most of the operations require a August API key to perform
  */
 class AugustSubAccounts extends core_1.AugustBase {
+    headers = null;
     constructor(baseConfig) {
         super(baseConfig);
-        this.headers = null;
         this.headers = {
             'x-environment': this.monitoring?.['x-environment'],
             'x-user-id': this.monitoring?.['x-user-id'],

package/lib/modules/sub-accounts/utils.d.ts

@@ -1,4 +1,4 @@
-import { IWSSubaccountSummary } from '../../types';
+import type { IWSSubaccountSummary } from '../../types';
 /**
  * Transform the raw API response to camelCase
  */

package/lib/modules/vaults/adapter.helpers.d.ts

@@ -4,9 +4,9 @@
  * Functions to support deposits with alternative tokens through swap adapters,
  * wrapper contracts, and Paraswap integration.
  */
-import { BaseContract, Signer, Wallet } from 'ethers';
-import { IAddress } from '../../types';
-import { IVaultAdapterConfig } from '../../types/vaults';
+import type { BaseContract, Signer, Wallet } from 'ethers';
+import type { IAddress } from '../../types';
+import type { IVaultAdapterConfig } from '../../types/vaults';
 /**
  * Get quote from Paraswap for token swap
  */

package/lib/modules/vaults/fetcher.d.ts

@@ -1,3 +1,28 @@
+import type { IAddress } from '../../types';
+/**
+ * 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.
+ */
+export declare function fetchArchivedVaults(): Promise<Set<string>>;
+/**
+ * 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.
+ */
+export declare function isArchivedVault(vaultAddress: IAddress): Promise<boolean>;
 /**
  * Specialized vault fetching with enhanced retry logic and fallback strategies
  * This function attempts to fetch vault data with multiple fallback approaches

package/lib/modules/vaults/fetcher.js

@@ -1,11 +1,61 @@
 "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 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.fetchAugustPublic)(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) {
@@ -151,7 +201,7 @@ async function fetchVaultsComprehensive(vaults, fetchFn, options = {}) {
                 catch (error) {
                     lastError = error;
                     if (attempts < maxRetries) {
-                        const delay = baseDelay * Math.pow(2, attempts - 1);
+                        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));
                     }