@augustdigital/sdk 8.16.0 → 8.16.1

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.16.0";
+export declare const SDK_VERSION = "8.16.1";

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.16.0';
+exports.SDK_VERSION = '8.16.1';
 //# sourceMappingURL=version.js.map

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

@@ -339,6 +339,31 @@ export interface PnlHistoryConsistencyParams {
  * ```
  */
 export declare function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, totalWithdrawnRaw, currentPositionRaw, }: PnlHistoryConsistencyParams): void;
+/**
+ * Sum a wallet's per-asset deposits into the vault's own decimals, at face
+ * value — 1 unit of any deposited asset is treated as 1 unit of the vault's
+ * reporting currency, with no live price conversion.
+ *
+ * Used by {@link getVaultUserLifetimePnl} for `totalDeposited`. Pre-deposit
+ * multi-asset vaults only accept dollar-pegged stablecoins (USDC, USDT, DAI,
+ * USDS, RLUSD, etc.) into a dollar-denominated vault, so face value is a
+ * reasonable stand-in for USD value. This intentionally does NOT re-quote
+ * through a live price oracle: doing so priced a historical deposit at
+ * today's market rate, so `totalDeposited` (and lifetimePnl) drifted between
+ * calls purely from stablecoin peg noise, and approximately re-inflated
+ * deposits back toward face value — which silently excluded the vault's
+ * entry fee from PnL. The fee is money the user actually paid, so PnL must
+ * be computed net of it.
+ *
+ * @param depositsByAsset - Raw deposited amount per asset, keyed by
+ *   lowercased asset address (or `'default'` / `'lz-default'` for
+ *   single-asset / cross-chain rows).
+ * @param assetDecimals - Decimals for each key in `depositsByAsset`.
+ * @param vaultDecimals - The vault's own decimals — the target scale every
+ *   asset is rescaled to.
+ * @returns Total deposited, in raw base units at `vaultDecimals`.
+ */
+export declare function sumDepositsAtFaceValue(depositsByAsset: Map<string, bigint>, assetDecimals: Map<string, number>, vaultDecimals: number): bigint;
 /**
  * Calculate lifetime PnL for a user in a specific vault.
  *
@@ -347,6 +372,15 @@ export declare function assertPnlHistoryConsistent({ vault, wallet, hasDeposits,
  * 2. Fetch user's current assets (balanceOf * sharePrice via convertToAssets)
  * 3. Calculate PnL = assets withdrawn + current assets - assets deposited
  *
+ * `totalDeposited` is the face value of what the user actually paid in
+ * (each deposited asset's raw amount, rescaled to the vault's decimals — no
+ * live price conversion), so any entry/exit fee the vault charges is
+ * automatically counted as a cost against PnL rather than excluded from it.
+ * Pre-deposit multi-asset vaults are assumed to only accept dollar-pegged
+ * stablecoins into a dollar-denominated vault; a vault accepting a
+ * non-pegged deposit asset would need deposit-time price conversion, which
+ * this function does not perform.
+ *
  * @param vault - Vault contract address
  * @param wallet - User wallet address
  * @param options - RPC configuration and service options

package/lib/modules/vaults/getters.js

@@ -54,6 +54,7 @@ exports.registerUserForPoints = registerUserForPoints;
 exports.fetchPointsLeaderboard = fetchPointsLeaderboard;
 exports.getYieldLastRealizedOn = getYieldLastRealizedOn;
 exports.assertPnlHistoryConsistent = assertPnlHistoryConsistent;
+exports.sumDepositsAtFaceValue = sumDepositsAtFaceValue;
 exports.getVaultUserLifetimePnl = getVaultUserLifetimePnl;
 exports.getVaultPnl = getVaultPnl;
 exports.getVaultHistoricalTimeseries = getVaultHistoricalTimeseries;
@@ -1898,6 +1899,46 @@ function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, totalWithdrawn
         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 } });
     }
 }
+/**
+ * Sum a wallet's per-asset deposits into the vault's own decimals, at face
+ * value — 1 unit of any deposited asset is treated as 1 unit of the vault's
+ * reporting currency, with no live price conversion.
+ *
+ * Used by {@link getVaultUserLifetimePnl} for `totalDeposited`. Pre-deposit
+ * multi-asset vaults only accept dollar-pegged stablecoins (USDC, USDT, DAI,
+ * USDS, RLUSD, etc.) into a dollar-denominated vault, so face value is a
+ * reasonable stand-in for USD value. This intentionally does NOT re-quote
+ * through a live price oracle: doing so priced a historical deposit at
+ * today's market rate, so `totalDeposited` (and lifetimePnl) drifted between
+ * calls purely from stablecoin peg noise, and approximately re-inflated
+ * deposits back toward face value — which silently excluded the vault's
+ * entry fee from PnL. The fee is money the user actually paid, so PnL must
+ * be computed net of it.
+ *
+ * @param depositsByAsset - Raw deposited amount per asset, keyed by
+ *   lowercased asset address (or `'default'` / `'lz-default'` for
+ *   single-asset / cross-chain rows).
+ * @param assetDecimals - Decimals for each key in `depositsByAsset`.
+ * @param vaultDecimals - The vault's own decimals — the target scale every
+ *   asset is rescaled to.
+ * @returns Total deposited, in raw base units at `vaultDecimals`.
+ */
+function sumDepositsAtFaceValue(depositsByAsset, assetDecimals, vaultDecimals) {
+    let total = BigInt(0);
+    for (const [assetAddress, rawAmount] of depositsByAsset) {
+        const assetDec = assetDecimals.get(assetAddress) ?? vaultDecimals;
+        if (assetDec === vaultDecimals) {
+            total += rawAmount;
+        }
+        else if (assetDec > vaultDecimals) {
+            total += rawAmount / BigInt(10 ** (assetDec - vaultDecimals));
+        }
+        else {
+            total += rawAmount * BigInt(10 ** (vaultDecimals - assetDec));
+        }
+    }
+    return total;
+}
 /**
  * Calculate lifetime PnL for a user in a specific vault.
  *
@@ -1906,6 +1947,15 @@ function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, totalWithdrawn
  * 2. Fetch user's current assets (balanceOf * sharePrice via convertToAssets)
  * 3. Calculate PnL = assets withdrawn + current assets - assets deposited
  *
+ * `totalDeposited` is the face value of what the user actually paid in
+ * (each deposited asset's raw amount, rescaled to the vault's decimals — no
+ * live price conversion), so any entry/exit fee the vault charges is
+ * automatically counted as a cost against PnL rather than excluded from it.
+ * Pre-deposit multi-asset vaults are assumed to only accept dollar-pegged
+ * stablecoins into a dollar-denominated vault; a vault accepting a
+ * non-pegged deposit asset would need deposit-time price conversion, which
+ * this function does not perform.
+ *
  * @param vault - Vault contract address
  * @param wallet - User wallet address
  * @param options - RPC configuration and service options
@@ -2069,32 +2119,7 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
                 assetDecimals.set(assetAddress, dec);
             }
         }));
-        // Store deposits as a map: assetAddress -> INormalizedNumber (with correct decimals)
-        const totalDepositedRaw = new Map();
-        for (const [assetAddress, rawAmount] of depositsByAsset) {
-            const assetDec = assetDecimals.get(assetAddress) ?? decimals;
-            totalDepositedRaw.set(assetAddress, (0, core_1.toNormalizedBn)(rawAmount, assetDec));
-        }
-        // Fetch USD prices for each unique deposit asset in parallel
-        const assetPrices = new Map();
-        if (tokenizedVault.chain) {
-            await Promise.all(Array.from(depositsByAsset.keys()).map(async (assetAddress) => {
-                if (assetAddress === 'default' || assetAddress === 'lz-default') {
-                    // Will use underlying asset price later
-                    assetPrices.set(assetAddress, 0);
-                }
-                else {
-                    try {
-                        const price = await (0, core_1.fetchTokenPriceByAddress)(assetAddress, tokenizedVault.chain, options?.headers);
-                        assetPrices.set(assetAddress, price);
-                    }
-                    catch (error) {
-                        core_1.Logger.log.warn('getVaultUserLifetimePnl:fetchAssetPrice', `Failed to fetch price for ${assetAddress}: ${error}`);
-                        assetPrices.set(assetAddress, 0);
-                    }
-                }
-            }));
-        }
+        const totalDepositedNativeRaw = sumDepositsAtFaceValue(depositsByAsset, assetDecimals, decimals);
         const { underlyingTokenSymbol, underlyingAssetAddress } = await underlyingSymbolPromise;
         // Calculate current position value and fetch price in parallel
         let currentPositionValue = (0, core_1.toNormalizedBn)(0, decimals);
@@ -2246,15 +2271,12 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
         if (tokenPriceUsd <= 0) {
             core_1.Logger.log.warn('getVaultUserLifetimePnl:tokenPrice', `Invalid underlying token price: ${tokenPriceUsd}, using fallback of 1`);
         }
-        // Sum all deposited amounts in USD using each asset's own price
-        let totalDepositedUsd = 0;
-        for (const [assetAddress, normalizedAmount] of totalDepositedRaw) {
-            // Use the asset-specific price, or underlying price for 'default'
-            const assetPrice = assetAddress === 'default' || assetAddress === 'lz-default'
-                ? effectiveTokenPrice
-                : assetPrices.get(assetAddress) || effectiveTokenPrice;
-            totalDepositedUsd += Number(normalizedAmount.normalized) * assetPrice;
-        }
+        // totalDeposited is already in the vault's own decimals (face value,
+        // computed above) — convert to USD with the same underlying price used
+        // for the other two legs below, so all three legs share one conversion
+        // factor instead of drifting independently against each other.
+        const totalDeposited = (0, core_1.toNormalizedBn)(totalDepositedNativeRaw, decimals);
+        const totalDepositedUsd = Number(totalDeposited.normalized) * effectiveTokenPrice;
         const totalWithdrawnUsd = Number(totalWithdrawn.normalized) * effectiveTokenPrice;
         const currentPositionValueUsd = Number(currentPositionValue.normalized) * effectiveTokenPrice;
         // Calculate lifetimePnl in USD first (since deposits may be in different tokens with different prices)
@@ -2262,12 +2284,6 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
         // Use BigInt-scaled arithmetic to minimize precision loss when converting USD to native
         const scaleFactor = BigInt(10 ** 18); // High precision scale
         const tokenPriceScaled = BigInt(Math.round(effectiveTokenPrice * Number(scaleFactor)));
-        // Convert totalDepositedUsd to native units for backwards compatibility
-        const totalDepositedUsdScaled = BigInt(Math.round(totalDepositedUsd * Number(scaleFactor)));
-        const totalDepositedNativeRaw = tokenPriceScaled > BigInt(0)
-            ? (totalDepositedUsdScaled * BigInt(10 ** decimals)) / tokenPriceScaled
-            : BigInt(0);
-        const totalDeposited = (0, core_1.toNormalizedBn)(totalDepositedNativeRaw, decimals);
         // Convert lifetimePnlUsd to native units
         const lifetimePnlUsdScaled = BigInt(Math.round(lifetimePnlUsd * Number(scaleFactor)));
         const lifetimePnlRaw = tokenPriceScaled > BigInt(0)

package/lib/sdk.d.ts

@@ -18986,6 +18986,15 @@ declare function assertNotStellar(address: string, operation: string): void;
               * 2. Fetch user's current assets (balanceOf * sharePrice via convertToAssets)
               * 3. Calculate PnL = assets withdrawn + current assets - assets deposited
               *
+              * `totalDeposited` is the face value of what the user actually paid in
+              * (each deposited asset's raw amount, rescaled to the vault's decimals — no
+              * live price conversion), so any entry/exit fee the vault charges is
+              * automatically counted as a cost against PnL rather than excluded from it.
+              * Pre-deposit multi-asset vaults are assumed to only accept dollar-pegged
+              * stablecoins into a dollar-denominated vault; a vault accepting a
+              * non-pegged deposit asset would need deposit-time price conversion, which
+              * this function does not perform.
+              *
               * @param vault - Vault contract address
               * @param wallet - User wallet address
               * @param options - RPC configuration and service options
@@ -24959,6 +24968,32 @@ declare function assertNotStellar(address: string, operation: string): void;
                                  transformEmberVaultsToIVaults(emberVaults: IEmberVault[]): IVault[];
                              }
 
+                             /**
+                              * Sum a wallet's per-asset deposits into the vault's own decimals, at face
+                              * value — 1 unit of any deposited asset is treated as 1 unit of the vault's
+                              * reporting currency, with no live price conversion.
+                              *
+                              * Used by {@link getVaultUserLifetimePnl} for `totalDeposited`. Pre-deposit
+                              * multi-asset vaults only accept dollar-pegged stablecoins (USDC, USDT, DAI,
+                              * USDS, RLUSD, etc.) into a dollar-denominated vault, so face value is a
+                              * reasonable stand-in for USD value. This intentionally does NOT re-quote
+                              * through a live price oracle: doing so priced a historical deposit at
+                              * today's market rate, so `totalDeposited` (and lifetimePnl) drifted between
+                              * calls purely from stablecoin peg noise, and approximately re-inflated
+                              * deposits back toward face value — which silently excluded the vault's
+                              * entry fee from PnL. The fee is money the user actually paid, so PnL must
+                              * be computed net of it.
+                              *
+                              * @param depositsByAsset - Raw deposited amount per asset, keyed by
+                              *   lowercased asset address (or `'default'` / `'lz-default'` for
+                              *   single-asset / cross-chain rows).
+                              * @param assetDecimals - Decimals for each key in `depositsByAsset`.
+                              * @param vaultDecimals - The vault's own decimals — the target scale every
+                              *   asset is rescaled to.
+                              * @returns Total deposited, in raw base units at `vaultDecimals`.
+                              */
+                             export declare function sumDepositsAtFaceValue(depositsByAsset: Map<string, bigint>, assetDecimals: Map<string, number>, vaultDecimals: number): bigint;
+
                              /**
                               * Address of the `SwapRouter` periphery contract on each supported chain.
                               *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@augustdigital/sdk",
-  "version": "8.16.0",
+  "version": "8.16.1",
   "main": "lib/index.js",
   "types": "lib/sdk.d.ts",
   "keywords": [