@augustdigital/sdk 8.13.0 → 8.15.0

package/lib/core/analytics/version.d.ts

@@ -3,4 +3,4 @@
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-export declare const SDK_VERSION = "8.13.0";
+export declare const SDK_VERSION = "8.15.0";

package/lib/core/analytics/version.js

@@ -6,5 +6,5 @@ exports.SDK_VERSION = void 0;
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-exports.SDK_VERSION = '8.13.0';
+exports.SDK_VERSION = '8.15.0';
 //# sourceMappingURL=version.js.map

package/lib/core/errors/index.d.ts

@@ -15,7 +15,7 @@
  * ```
  */
 /** Stable error codes attached to SDK errors. */
-export type AugustErrorCode = 'AUTH_MISSING_KEY' | 'AUTH_INVALID_KEY' | 'AUTH_FORBIDDEN' | 'AUTH_UNAUTHORIZED' | 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED' | 'NETWORK_ERROR' | 'TIMEOUT' | 'RATE_LIMITED' | 'SERVER_ERROR' | 'UNKNOWN';
+export type AugustErrorCode = 'AUTH_MISSING_KEY' | 'AUTH_INVALID_KEY' | 'AUTH_FORBIDDEN' | 'AUTH_UNAUTHORIZED' | 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED' | 'NETWORK_ERROR' | 'TIMEOUT' | 'RATE_LIMITED' | 'SERVER_ERROR' | 'HISTORY_UNAVAILABLE' | 'UNKNOWN';
 /** Options accepted by every SDK error constructor. */
 export interface AugustErrorOptions {
     /** Original error preserved for stack-trace chaining. */
@@ -72,5 +72,43 @@ export declare class AugustServerError extends AugustSDKError {
     constructor(status: number, message: string, options?: AugustErrorOptions);
     toJSON(): Record<string, unknown>;
 }
+/**
+ * Transaction/position history required to compute a value could not be
+ * retrieved or was empty, so the computed result would be wrong rather than
+ * merely missing.
+ *
+ * Motivation — the 2026-07-09 lifetime-PnL over-inflation incident. Lifetime
+ * PnL is `currentPosition + totalWithdrawn - totalDeposited`. Every
+ * history-fetch failure (deleted subgraph, subgraph deployed against the wrong
+ * ABI, missing archive backfill, deposits indexed on a different
+ * chain/contract) collapses the deposit/withdrawal history to empty. With
+ * `deposited = 0` and `withdrawn = 0` but a live on-chain `position > 0`, the
+ * formula degenerates to reporting the entire position as profit. Throwing this
+ * typed error makes that unrecoverable state fail loudly instead of returning
+ * an inflated number that looks plausible.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sdk.vaults.getVaultUserLifetimePnl({ vault, wallet, options });
+ * } catch (err) {
+ *   if (err instanceof AugustHistoryUnavailableError) {
+ *     // History backfill is broken — surface "temporarily unavailable",
+ *     // never a fabricated PnL number.
+ *     showUnavailable(err.context);
+ *   } else throw err;
+ * }
+ * ```
+ */
+export declare class AugustHistoryUnavailableError extends AugustSDKError {
+    /**
+     * @param message - Human-readable description of the missing history. Callers
+     *   pass the same `#<method>::<vault>::<wallet>` prefix the surrounding getter
+     *   uses so log grouping stays consistent.
+     * @param options - Standard SDK error options. `context` should carry the
+     *   `{ vault, wallet }` (or equivalent) identifiers that scope the failure.
+     */
+    constructor(message: string, options?: AugustErrorOptions);
+}
 /** Type guard. Works across realms (e.g. Web Worker / VM contexts). */
 export declare function isAugustSDKError(err: unknown): err is AugustSDKError;

package/lib/core/errors/index.js

@@ -16,7 +16,7 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AugustServerError = exports.AugustRateLimitError = exports.AugustValidationError = exports.AugustTimeoutError = exports.AugustNetworkError = exports.AugustAuthError = exports.AugustSDKError = void 0;
+exports.AugustHistoryUnavailableError = exports.AugustServerError = exports.AugustRateLimitError = exports.AugustValidationError = exports.AugustTimeoutError = exports.AugustNetworkError = exports.AugustAuthError = exports.AugustSDKError = void 0;
 exports.isAugustSDKError = isAugustSDKError;
 /** Base class for all SDK errors. */
 class AugustSDKError extends Error {
@@ -131,6 +131,48 @@ class AugustServerError extends AugustSDKError {
     }
 }
 exports.AugustServerError = AugustServerError;
+/**
+ * Transaction/position history required to compute a value could not be
+ * retrieved or was empty, so the computed result would be wrong rather than
+ * merely missing.
+ *
+ * Motivation — the 2026-07-09 lifetime-PnL over-inflation incident. Lifetime
+ * PnL is `currentPosition + totalWithdrawn - totalDeposited`. Every
+ * history-fetch failure (deleted subgraph, subgraph deployed against the wrong
+ * ABI, missing archive backfill, deposits indexed on a different
+ * chain/contract) collapses the deposit/withdrawal history to empty. With
+ * `deposited = 0` and `withdrawn = 0` but a live on-chain `position > 0`, the
+ * formula degenerates to reporting the entire position as profit. Throwing this
+ * typed error makes that unrecoverable state fail loudly instead of returning
+ * an inflated number that looks plausible.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sdk.vaults.getVaultUserLifetimePnl({ vault, wallet, options });
+ * } catch (err) {
+ *   if (err instanceof AugustHistoryUnavailableError) {
+ *     // History backfill is broken — surface "temporarily unavailable",
+ *     // never a fabricated PnL number.
+ *     showUnavailable(err.context);
+ *   } else throw err;
+ * }
+ * ```
+ */
+class AugustHistoryUnavailableError extends AugustSDKError {
+    /**
+     * @param message - Human-readable description of the missing history. Callers
+     *   pass the same `#<method>::<vault>::<wallet>` prefix the surrounding getter
+     *   uses so log grouping stays consistent.
+     * @param options - Standard SDK error options. `context` should carry the
+     *   `{ vault, wallet }` (or equivalent) identifiers that scope the failure.
+     */
+    constructor(message, options) {
+        super('HISTORY_UNAVAILABLE', message, options);
+        this.name = 'AugustHistoryUnavailableError';
+    }
+}
+exports.AugustHistoryUnavailableError = AugustHistoryUnavailableError;
 /** Type guard. Works across realms (e.g. Web Worker / VM contexts). */
 function isAugustSDKError(err) {
     return (err instanceof AugustSDKError ||

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

@@ -46,3 +46,44 @@ export declare const SUBGRAPH_POOL_URLS: (apiKey: string, chainId?: number, pool
  *   generated fallback.
  */
 export declare const getDefaultSubgraphUrl: (_network: string, _symbol: string) => string | undefined;
+/**
+ * Resolve whether a single fee (management or performance) is currently waived.
+ *
+ * Backend-driven, per AUGUST-5584. This centralizes logic that previously lived —
+ * and diverged — across two upshift-app components. The resolution is deliberately
+ * split between the backend and the SDK:
+ *
+ * - The backend `isFeeWaivedToggle` (`platform_fee_override.is_fee_waived`) is both
+ *   the master enable AND the TVL latch. Retool config takes precedence over live
+ *   TVL, and the backend flips this flag `false` once live TVL crosses the
+ *   configured threshold. That flip is one-way: if TVL later falls back below the
+ *   threshold the waiver does NOT re-apply. The SDK therefore does no TVL math and
+ *   never reads `latest_reported_tvl` here — trusting the flag preserves the latch.
+ * - The **date** window is time-dependent, so it cannot be a static DB flag; the SDK
+ *   evaluates it live against the clock.
+ *
+ * Resolution:
+ * - Toggle off  → never waived (also the only "hide" path once TVL trips the latch).
+ * - Toggle on, both date and TVL blank → indefinite manual waiver → waived.
+ * - Toggle on with a date window → waived while `now < waivedUntilDate`.
+ * - Toggle on with a TVL threshold configured → waived (the backend keeps the toggle
+ *   on only while live TVL is under the threshold).
+ *
+ * @param isFeeWaivedToggle - Backend master/TVL-latch flag. `false` ⇒ never waived.
+ * @param waivedUntilDate - ISO datetime string the waiver runs until, or `null` for
+ *   no date window. An unparseable string yields `NaN`, which is never `> now`, so
+ *   it correctly contributes no date-based waiver.
+ * @param waivedUntilTvl - Configured TVL threshold in whole USD, or `null`. Used only
+ *   to detect that a TVL-based waiver was set (values `<= 0` are treated as unset);
+ *   the threshold comparison itself is owned by the backend.
+ * @param now - Clock, injected for deterministic testing. Defaults to `new Date()`.
+ * @returns `true` if the UI should present this fee as "Fee Waived" right now.
+ * @example
+ * ```ts
+ * // Toggle on, 30-day window still open → waived.
+ * resolveFeeWaived(true, '2099-01-01T00:00:00Z', null); // true
+ * // Toggle off overrides everything → not waived.
+ * resolveFeeWaived(false, '2099-01-01T00:00:00Z', 10_000_000); // false
+ * ```
+ */
+export declare function resolveFeeWaived(isFeeWaivedToggle: boolean, waivedUntilDate: string | null, waivedUntilTvl: number | null, now?: Date): boolean;

package/lib/core/helpers/vaults.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDefaultSubgraphUrl = exports.SUBGRAPH_POOL_URLS = exports.AVAX_PRICE_FEED_ADDRESS = exports.REWARD_DISTRIBUTOR_ADDRESS = exports.getVaultVersionV2 = exports.getVaultVersion = exports.getAddressChainType = exports.isBadVault = exports.isBadTransaction = void 0;
 exports.getVaultSymbol = getVaultSymbol;
+exports.resolveFeeWaived = resolveFeeWaived;
 const ethers_1 = require("ethers");
 const vaults_1 = require("../constants/vaults");
 const web3_1 = require("./web3");
@@ -179,4 +180,56 @@ const getDefaultSubgraphUrl = (_network, _symbol) => {
     return undefined;
 };
 exports.getDefaultSubgraphUrl = getDefaultSubgraphUrl;
+/**
+ * Resolve whether a single fee (management or performance) is currently waived.
+ *
+ * Backend-driven, per AUGUST-5584. This centralizes logic that previously lived —
+ * and diverged — across two upshift-app components. The resolution is deliberately
+ * split between the backend and the SDK:
+ *
+ * - The backend `isFeeWaivedToggle` (`platform_fee_override.is_fee_waived`) is both
+ *   the master enable AND the TVL latch. Retool config takes precedence over live
+ *   TVL, and the backend flips this flag `false` once live TVL crosses the
+ *   configured threshold. That flip is one-way: if TVL later falls back below the
+ *   threshold the waiver does NOT re-apply. The SDK therefore does no TVL math and
+ *   never reads `latest_reported_tvl` here — trusting the flag preserves the latch.
+ * - The **date** window is time-dependent, so it cannot be a static DB flag; the SDK
+ *   evaluates it live against the clock.
+ *
+ * Resolution:
+ * - Toggle off  → never waived (also the only "hide" path once TVL trips the latch).
+ * - Toggle on, both date and TVL blank → indefinite manual waiver → waived.
+ * - Toggle on with a date window → waived while `now < waivedUntilDate`.
+ * - Toggle on with a TVL threshold configured → waived (the backend keeps the toggle
+ *   on only while live TVL is under the threshold).
+ *
+ * @param isFeeWaivedToggle - Backend master/TVL-latch flag. `false` ⇒ never waived.
+ * @param waivedUntilDate - ISO datetime string the waiver runs until, or `null` for
+ *   no date window. An unparseable string yields `NaN`, which is never `> now`, so
+ *   it correctly contributes no date-based waiver.
+ * @param waivedUntilTvl - Configured TVL threshold in whole USD, or `null`. Used only
+ *   to detect that a TVL-based waiver was set (values `<= 0` are treated as unset);
+ *   the threshold comparison itself is owned by the backend.
+ * @param now - Clock, injected for deterministic testing. Defaults to `new Date()`.
+ * @returns `true` if the UI should present this fee as "Fee Waived" right now.
+ * @example
+ * ```ts
+ * // Toggle on, 30-day window still open → waived.
+ * resolveFeeWaived(true, '2099-01-01T00:00:00Z', null); // true
+ * // Toggle off overrides everything → not waived.
+ * resolveFeeWaived(false, '2099-01-01T00:00:00Z', 10_000_000); // false
+ * ```
+ */
+function resolveFeeWaived(isFeeWaivedToggle, waivedUntilDate, waivedUntilTvl, now = new Date()) {
+    // Master toggle off ⇒ never waived. Also satisfies the one-way TVL latch: the
+    // backend has already flipped this false when live TVL crossed the threshold.
+    if (!isFeeWaivedToggle)
+        return false;
+    const isDateActive = waivedUntilDate != null && new Date(waivedUntilDate) > now;
+    const isTvlConfigured = waivedUntilTvl != null && waivedUntilTvl > 0;
+    // Toggle on but neither trigger configured ⇒ indefinite manual waiver.
+    if (waivedUntilDate == null && !isTvlConfigured)
+        return true;
+    return isDateActive || isTvlConfigured;
+}
 //# sourceMappingURL=vaults.js.map

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

@@ -273,6 +273,72 @@ export declare function getYieldLastRealizedOn({ vault, options, }: {
     vault: IAddress;
     options: IVaultBaseOptions;
 }): Promise<number>;
+/** Inputs the lifetime-PnL history guard inspects. */
+export interface PnlHistoryConsistencyParams {
+    /** Vault contract address, used for the error message and context. */
+    vault: IAddress;
+    /** User wallet address, used for the error message and context. */
+    wallet: IAddress;
+    /**
+     * Whether the resolved deposit history contains at least one deposit record
+     * (subgraph deposits or LayerZero cross-chain deposits).
+     */
+    hasDeposits: boolean;
+    /** Total withdrawn, in raw base units (asset decimals). */
+    totalWithdrawnRaw: bigint;
+    /** Current on-chain position value, in raw base units (asset decimals). */
+    currentPositionRaw: bigint;
+}
+/**
+ * Guard against the 2026-07-09 lifetime-PnL over-inflation failure mode.
+ *
+ * Lifetime PnL is `currentPosition + totalWithdrawn - totalDeposited`. When the
+ * deposit/withdrawal history fails to load it collapses to empty, so both
+ * `totalDeposited` and `totalWithdrawn` read as zero. If the wallet still holds
+ * a live on-chain position, the formula degenerates to reporting the entire
+ * position as pure profit — a plausible-looking but wrong number.
+ *
+ * This guard rejects exactly that state: a non-zero position with no recorded
+ * deposits *and* no recorded withdrawals. Any of the following is treated as
+ * consistent and passes:
+ * - deposits are present (the normal, computable case);
+ * - withdrawals are present (a fully-exited-then-re-entered position is still
+ *   computable — the withdrawal records prove history loaded);
+ * - the current position is zero (the wallet never interacted or fully exited,
+ *   so a zero PnL is correct, not inflated).
+ *
+ * Pure and synchronous — no RPC, no I/O — so it is safe to call inside the hot
+ * path with no added latency.
+ *
+ * Known imprecision — vault shares are transferable ERC-20 receipt tokens, so a
+ * wallet that *received* shares via a direct token transfer (never deposited,
+ * never withdrew) legitimately has `position > 0` with no history records and
+ * will throw `HISTORY_UNAVAILABLE` even though its history loaded fine. This is
+ * not a regression — the pre-guard formula reported that same position as 100%
+ * profit, which was also wrong — but the error message is misleading for that
+ * (rare) path. If receipt-token transfer becomes a real user flow, distinguish
+ * it here (e.g. by checking for a share-transfer event) rather than widening
+ * the guard.
+ *
+ * @param params - See {@link PnlHistoryConsistencyParams}.
+ * @returns `void` when the history is consistent.
+ * @throws {@link AugustHistoryUnavailableError} with code `HISTORY_UNAVAILABLE`
+ *   and `context: { vault, wallet }` when a non-zero position has neither
+ *   deposits nor withdrawals recorded. The message carries the
+ *   `#getVaultUserLifetimePnl::<vault>::<wallet>` prefix so it groups with the
+ *   other errors leaving the getter.
+ * @example
+ * ```ts
+ * assertPnlHistoryConsistent({
+ *   vault,
+ *   wallet,
+ *   hasDeposits: depositsByAsset.size > 0,
+ *   totalWithdrawnRaw,
+ *   currentPositionRaw: currentPositionValue.raw,
+ * });
+ * ```
+ */
+export declare function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, totalWithdrawnRaw, currentPositionRaw, }: PnlHistoryConsistencyParams): void;
 /**
  * Calculate lifetime PnL for a user in a specific vault.
  *

package/lib/modules/vaults/getters.js

@@ -53,6 +53,7 @@ exports.getUserPoints = getUserPoints;
 exports.registerUserForPoints = registerUserForPoints;
 exports.fetchPointsLeaderboard = fetchPointsLeaderboard;
 exports.getYieldLastRealizedOn = getYieldLastRealizedOn;
+exports.assertPnlHistoryConsistent = assertPnlHistoryConsistent;
 exports.getVaultUserLifetimePnl = getVaultUserLifetimePnl;
 exports.getVaultPnl = getVaultPnl;
 exports.getVaultHistoricalTimeseries = getVaultHistoricalTimeseries;
@@ -85,6 +86,7 @@ const date_utils_1 = require("./utils/date-utils");
 const call_data_decoder_1 = require("./utils/call-data-decoder");
 const deposits_1 = require("../../services/layerzero/deposits");
 const redeems_1 = require("../../services/layerzero/redeems");
+const errors_1 = require("../../core/errors");
 /**
  * Vault Data Getters
  *
@@ -1840,6 +1842,62 @@ async function getYieldLastRealizedOn({ vault, options, }) {
         throw new Error(`#getYieldLastRealizedOn::${vault}:${errorMessage}`);
     }
 }
+/**
+ * Guard against the 2026-07-09 lifetime-PnL over-inflation failure mode.
+ *
+ * Lifetime PnL is `currentPosition + totalWithdrawn - totalDeposited`. When the
+ * deposit/withdrawal history fails to load it collapses to empty, so both
+ * `totalDeposited` and `totalWithdrawn` read as zero. If the wallet still holds
+ * a live on-chain position, the formula degenerates to reporting the entire
+ * position as pure profit — a plausible-looking but wrong number.
+ *
+ * This guard rejects exactly that state: a non-zero position with no recorded
+ * deposits *and* no recorded withdrawals. Any of the following is treated as
+ * consistent and passes:
+ * - deposits are present (the normal, computable case);
+ * - withdrawals are present (a fully-exited-then-re-entered position is still
+ *   computable — the withdrawal records prove history loaded);
+ * - the current position is zero (the wallet never interacted or fully exited,
+ *   so a zero PnL is correct, not inflated).
+ *
+ * Pure and synchronous — no RPC, no I/O — so it is safe to call inside the hot
+ * path with no added latency.
+ *
+ * Known imprecision — vault shares are transferable ERC-20 receipt tokens, so a
+ * wallet that *received* shares via a direct token transfer (never deposited,
+ * never withdrew) legitimately has `position > 0` with no history records and
+ * will throw `HISTORY_UNAVAILABLE` even though its history loaded fine. This is
+ * not a regression — the pre-guard formula reported that same position as 100%
+ * profit, which was also wrong — but the error message is misleading for that
+ * (rare) path. If receipt-token transfer becomes a real user flow, distinguish
+ * it here (e.g. by checking for a share-transfer event) rather than widening
+ * the guard.
+ *
+ * @param params - See {@link PnlHistoryConsistencyParams}.
+ * @returns `void` when the history is consistent.
+ * @throws {@link AugustHistoryUnavailableError} with code `HISTORY_UNAVAILABLE`
+ *   and `context: { vault, wallet }` when a non-zero position has neither
+ *   deposits nor withdrawals recorded. The message carries the
+ *   `#getVaultUserLifetimePnl::<vault>::<wallet>` prefix so it groups with the
+ *   other errors leaving the getter.
+ * @example
+ * ```ts
+ * assertPnlHistoryConsistent({
+ *   vault,
+ *   wallet,
+ *   hasDeposits: depositsByAsset.size > 0,
+ *   totalWithdrawnRaw,
+ *   currentPositionRaw: currentPositionValue.raw,
+ * });
+ * ```
+ */
+function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, totalWithdrawnRaw, currentPositionRaw, }) {
+    const positionExists = currentPositionRaw > BigInt(0);
+    const noHistory = !hasDeposits && totalWithdrawnRaw === BigInt(0);
+    if (positionExists && noHistory) {
+        throw new errors_1.AugustHistoryUnavailableError(`#getVaultUserLifetimePnl::${vault}::${wallet}:transaction history unavailable — a live position exists but no deposits or withdrawals were indexed, so lifetime PnL cannot be computed without over-reporting the entire position as profit`, { context: { vault, wallet } });
+    }
+}
 /**
  * Calculate lifetime PnL for a user in a specific vault.
  *
@@ -2171,6 +2229,17 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
             totalWithdrawnRaw += totalWithdrawalsInShares;
         }
         const totalWithdrawn = (0, core_1.toNormalizedBn)(totalWithdrawnRaw, decimals);
+        // Guard the 2026-07-09 over-inflation incident: a live position with no
+        // deposits *and* no withdrawals means the history failed to load, and the
+        // PnL formula would report the whole position as profit. Fail loudly with a
+        // typed error instead of returning a fabricated number.
+        assertPnlHistoryConsistent({
+            vault,
+            wallet,
+            hasDeposits: depositsByAsset.size > 0,
+            totalWithdrawnRaw,
+            currentPositionRaw: BigInt(currentPositionValue.raw),
+        });
         const tokenPriceUsd = await pricePromise;
         // Validate token price and log warning if invalid
         const effectiveTokenPrice = tokenPriceUsd > 0 ? tokenPriceUsd : 1;
@@ -2223,6 +2292,11 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
     }
     catch (e) {
         core_1.Logger.log.error('getVaultUserLifetimePnl', e, { vault, wallet });
+        // Preserve the typed history guard so callers can distinguish an
+        // unavailable-history failure from a generic getter error. Its message
+        // already carries the `#getVaultUserLifetimePnl::vault::wallet` prefix.
+        if (e instanceof errors_1.AugustHistoryUnavailableError)
+            throw e;
         const errorMessage = e instanceof Error ? e.message : String(e);
         throw new Error(`#getVaultUserLifetimePnl::${vault}::${wallet}:${errorMessage}`);
     }

package/lib/modules/vaults/utils.js

@@ -330,6 +330,7 @@ function buildBackendVault(tokenizedVault, overrides) {
         historical_snapshots: tokenizedVault.historical_snapshots || [],
         address: tokenizedVault.address,
         historical_apy: tokenizedVault.historical_apy,
+        historical_compound_apy: tokenizedVault.historical_compound_apy,
         max_drawdown: tokenizedVault.max_drawdown,
         logoUrl: tokenizedVault.vault_logo_url || '/img/strategist/august.svg',
         description: tokenizedVault.description || '',
@@ -353,10 +354,10 @@ function buildBackendVault(tokenizedVault, overrides) {
         fees: {
             performance: tokenizedVault.weekly_performance_fee_bps || 0,
             management: tokenizedVault.platform_fee_override?.management_fee || 0,
-            isManagementWaived: false,
+            isManagementWaived: (0, vaults_1.resolveFeeWaived)(tokenizedVault.platform_fee_override?.is_fee_waived ?? false, tokenizedVault.management_fee_waived_until_date ?? null, tokenizedVault.management_fee_waived_until_tvl ?? null),
             managementFeeWaivedUntilDate: tokenizedVault.management_fee_waived_until_date ?? null,
             managementFeeWaivedUntilTvl: tokenizedVault.management_fee_waived_until_tvl ?? null,
-            isPerformanceWaived: false,
+            isPerformanceWaived: (0, vaults_1.resolveFeeWaived)(tokenizedVault.platform_fee_override?.is_fee_waived ?? false, tokenizedVault.performance_fee_waived_until_date ?? null, tokenizedVault.performance_fee_waived_until_tvl ?? null),
             performanceFeeWaivedUntilDate: tokenizedVault.performance_fee_waived_until_date ?? null,
             performanceFeeWaivedUntilTvl: tokenizedVault.performance_fee_waived_until_tvl ?? null,
         },
@@ -466,10 +467,10 @@ async function buildFormattedVault(provider, tokenizedVault, contractCalls) {
         fees: {
             performance: tokenizedVault.weekly_performance_fee_bps,
             management: tokenizedVault.platform_fee_override.management_fee,
-            isManagementWaived: tokenizedVault.platform_fee_override.is_fee_waived,
+            isManagementWaived: (0, vaults_1.resolveFeeWaived)(tokenizedVault.platform_fee_override.is_fee_waived, tokenizedVault.management_fee_waived_until_date, tokenizedVault.management_fee_waived_until_tvl),
             managementFeeWaivedUntilDate: tokenizedVault.management_fee_waived_until_date,
             managementFeeWaivedUntilTvl: tokenizedVault.management_fee_waived_until_tvl,
-            isPerformanceWaived: tokenizedVault.platform_fee_override.is_fee_waived,
+            isPerformanceWaived: (0, vaults_1.resolveFeeWaived)(tokenizedVault.platform_fee_override.is_fee_waived, tokenizedVault.performance_fee_waived_until_date, tokenizedVault.performance_fee_waived_until_tvl),
             performanceFeeWaivedUntilDate: tokenizedVault.performance_fee_waived_until_date,
             performanceFeeWaivedUntilTvl: tokenizedVault.performance_fee_waived_until_tvl,
         },
@@ -600,6 +601,7 @@ async function buildFormattedVault(provider, tokenizedVault, contractCalls) {
         maxDepositAmount: maxDepositAmount,
         receipt: receipt,
         historical_apy: tokenizedVault?.historical_apy,
+        historical_compound_apy: tokenizedVault?.historical_compound_apy,
         historical_snapshots: tokenizedVault?.historical_snapshots || [],
         max_drawdown: tokenizedVault?.max_drawdown,
         composabilityIntegrations: mapComposabilityIntegrations(tokenizedVault),