@augustdigital/sdk 8.7.2 → 8.8.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.7.2";
+export declare const SDK_VERSION = "8.8.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.7.2';
+exports.SDK_VERSION = '8.8.0';
 //# sourceMappingURL=version.js.map

package/lib/core/base.class.d.ts

@@ -63,6 +63,25 @@ export interface IAugustBase {
      * with different timeouts in the same process.
      */
     timeoutMs?: number;
+    /**
+     * Override the base URL for the SDK's unauthenticated `public` vault-catalog
+     * API (what `getVault` / `getVaults` / `fetchTokenizedVault` read from).
+     * Defaults to the compiled-in prod base
+     * (`https://api.augustdigital.io/api/v1`) when omitted — so production apps
+     * pass nothing and behaviour is unchanged.
+     *
+     * Set this ONLY for a non-prod deployment that runs against an isolated
+     * backend (e.g. a staging API serving staging-only vaults). Must be an
+     * absolute http(s) URL including any base path, e.g.
+     * `https://api.staging.augustdigital.io/api/v1`. Invalid values are ignored.
+     *
+     * Note: this is a process-global override on the underlying fetcher helpers,
+     * applied on EVERY construction — so the last `AugustSDK` instantiated is
+     * authoritative, and one that omits `publicApiBaseUrl` RESETS to the prod
+     * default. (Stricter than `timeoutMs`, which stays sticky when omitted, since
+     * a stale cross-environment base is higher blast-radius than a stale timeout.)
+     */
+    publicApiBaseUrl?: string;
 }
 interface IActiveNetwork {
     chainId: IChainId;
@@ -87,7 +106,7 @@ export declare class AugustBase {
      * @throws If `appName` is missing, malformed, or out of the allowed
      *   length range — see {@link IAugustBase.appName}.
      */
-    constructor({ appName, providers, keys, monitoring, analytics, versionCheck, timeoutMs, }: IAugustBase);
+    constructor({ appName, providers, keys, monitoring, analytics, versionCheck, timeoutMs, publicApiBaseUrl, }: IAugustBase);
     /**
      * Verify API keys and authorize SDK usage.
      * TODO: initialize class with appropriate keys and verify august key

package/lib/core/base.class.js

@@ -55,7 +55,7 @@ class AugustBase {
      * @throws If `appName` is missing, malformed, or out of the allowed
      *   length range — see {@link IAugustBase.appName}.
      */
-    constructor({ appName, providers = {}, keys, monitoring, analytics, versionCheck, timeoutMs, }) {
+    constructor({ appName, providers = {}, keys, monitoring, analytics, versionCheck, timeoutMs, publicApiBaseUrl, }) {
         // Validate first so the failure mode is a clear, actionable error before
         // any provider / analytics side effects run.
         this.appName = validateAppName(appName);
@@ -88,6 +88,13 @@ class AugustBase {
         if (typeof timeoutMs === 'number') {
             (0, fetcher_1.setSdkRequestTimeout)(timeoutMs);
         }
+        // Repoint the unauthenticated `public` vault-catalog API when a non-prod
+        // deployment supplies an isolated backend. Called UNCONDITIONALLY so each
+        // instance is authoritative: an instance that omits `publicApiBaseUrl`
+        // passes `null` and RESETS to the compiled-in prod default. Without this a
+        // prior staging instance would leak into a later prod instance in the same
+        // process — the inverse of the isolation this option exists to provide.
+        (0, fetcher_1.setPublicApiBaseUrl)(publicApiBaseUrl ?? null);
     }
     /**
      * Verify API keys and authorize SDK usage.

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

@@ -12,6 +12,23 @@ export declare const SPECIAL_CHAINS: {
     };
 };
 export declare const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+/**
+ * Decimal precision of the native gas token on every EVM chain this SDK
+ * supports (ETH, Base, Arbitrum, Avalanche, Polygon, BNB, HyperEVM, Unichain,
+ * Mezo, Monad, Plasma, Ink, Flare, Katana, Citrea, Fluent, Tempo).
+ *
+ * All of them use 18-decimal native tokens, so this is a single constant rather
+ * than a per-chain map. It exists because the native token has no ERC-20
+ * `decimals()` to read on-chain: when a subgraph row denominates an amount in
+ * the native token it is flagged with a sentinel address ({@link NATIVE_ADDRESS}
+ * or the zero address) instead of a real contract, and callers must substitute
+ * this value rather than attempting (and failing) a `decimals()` read.
+ *
+ * Non-EVM natives differ (SOL is 9, XLM is 7) and are handled by their own
+ * adapters — those chains never flow through the EVM `decimals()` path this
+ * constant serves.
+ */
+export declare const EVM_NATIVE_DECIMALS = 18;
 export declare const MIN_ABIS: {
     name: string;
     symbol: string;

package/lib/core/constants/web3.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FALLBACK_RPC_URLS = exports.FALLBACK_CHAINID = exports.FALLBACK_DECIMALS = exports.AVAILABLE_CHAINS = exports.NETWORKS = exports.ORACLE_CONTRACTS = exports.MIN_ABIS = exports.NATIVE_ADDRESS = exports.SPECIAL_CHAINS = void 0;
+exports.FALLBACK_RPC_URLS = exports.FALLBACK_CHAINID = exports.FALLBACK_DECIMALS = exports.AVAILABLE_CHAINS = exports.NETWORKS = exports.ORACLE_CONTRACTS = exports.MIN_ABIS = exports.EVM_NATIVE_DECIMALS = exports.NATIVE_ADDRESS = exports.SPECIAL_CHAINS = void 0;
 // Special Chains
 exports.SPECIAL_CHAINS = {
     solana: {
@@ -16,6 +16,23 @@ exports.SPECIAL_CHAINS = {
 };
 // General
 exports.NATIVE_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+/**
+ * Decimal precision of the native gas token on every EVM chain this SDK
+ * supports (ETH, Base, Arbitrum, Avalanche, Polygon, BNB, HyperEVM, Unichain,
+ * Mezo, Monad, Plasma, Ink, Flare, Katana, Citrea, Fluent, Tempo).
+ *
+ * All of them use 18-decimal native tokens, so this is a single constant rather
+ * than a per-chain map. It exists because the native token has no ERC-20
+ * `decimals()` to read on-chain: when a subgraph row denominates an amount in
+ * the native token it is flagged with a sentinel address ({@link NATIVE_ADDRESS}
+ * or the zero address) instead of a real contract, and callers must substitute
+ * this value rather than attempting (and failing) a `decimals()` read.
+ *
+ * Non-EVM natives differ (SOL is 9, XLM is 7) and are handled by their own
+ * adapters — those chains never flow through the EVM `decimals()` path this
+ * constant serves.
+ */
+exports.EVM_NATIVE_DECIMALS = 18;
 exports.MIN_ABIS = {
     name: 'function name() view returns (string)',
     symbol: 'function symbol() view returns (string)',

package/lib/core/fetcher.d.ts

@@ -41,6 +41,41 @@ export declare function setSdkRequestTimeout(ms?: number | null): void;
  * otherwise the compiled-in `REQUEST_TIMEOUT_MS`.
  */
 export declare function getSdkRequestTimeout(): number;
+/**
+ * Override the base URL used for `WEBSERVER_URL.public` requests — the
+ * unauthenticated vault-catalog API that `getVault` / `fetchTokenizedVault`
+ * (and the other `fetchAugustPublic` callers) read from. Defaults to the
+ * compiled-in prod base (`https://api.augustdigital.io/api/v1`); pass `null`
+ * (or call with no arguments) to clear.
+ *
+ * Intended for non-prod deployments that run against an ISOLATED backend
+ * (e.g. a staging API): set it once at construction via
+ * `IAugustBase.publicApiBaseUrl` so a staging-only vault resolves. Production
+ * leaves it unset, so behaviour is unchanged.
+ *
+ * This is a process-global override on the fetcher helpers. The SDK constructor
+ * calls it on EVERY instantiation (with `null` when `publicApiBaseUrl` is
+ * omitted), so the last `AugustSDK` instantiated is authoritative — a prod
+ * instance resets it to the default even after a prior staging instance set it.
+ * An invalid or non-http(s) URL is treated as "no override": it RESETS to the
+ * compiled-in default (warned) rather than retaining a prior value, so a bad env
+ * value can neither break fetches nor silently leave a previous instance's base
+ * in place.
+ *
+ * Whenever the effective base CHANGES, the shared public-response cache is
+ * cleared, so catalog data fetched from the previous backend is never served for
+ * the new one (e.g. a prod-cached vault leaking into a staging instance). Base
+ * changes happen at construction, when the cache is cold, so this is ~free.
+ *
+ * @param url - Absolute http(s) base URL (trailing slash is trimmed). `null`, or
+ *   an invalid / non-http(s) value, resets to the compiled-in public base.
+ */
+export declare function setPublicApiBaseUrl(url?: string | null): void;
+/**
+ * Read the active base for the `public` server — the SDK-level override if set,
+ * otherwise the compiled-in `WEBSERVER_URL.public`.
+ */
+export declare function getPublicApiBaseUrl(): string;
 import { CACHE, getSafeCache, setSafeCache } from './cache';
 export { CACHE, getSafeCache, setSafeCache };
 /**

package/lib/core/fetcher.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSafeCache = exports.getSafeCache = exports.CACHE = void 0;
 exports.setSdkRequestTimeout = setSdkRequestTimeout;
 exports.getSdkRequestTimeout = getSdkRequestTimeout;
+exports.setPublicApiBaseUrl = setPublicApiBaseUrl;
+exports.getPublicApiBaseUrl = getPublicApiBaseUrl;
 exports.fetchAugustWithKey = fetchAugustWithKey;
 exports.fetchAugustPublic = fetchAugustPublic;
 exports.fetchAugustWithBearer = fetchAugustWithBearer;
@@ -73,6 +75,78 @@ function setSdkRequestTimeout(ms = null) {
 function getSdkRequestTimeout() {
     return SDK_REQUEST_TIMEOUT_OVERRIDE ?? core_2.REQUEST_TIMEOUT_MS;
 }
+let PUBLIC_API_BASE_OVERRIDE = null;
+/**
+ * Override the base URL used for `WEBSERVER_URL.public` requests — the
+ * unauthenticated vault-catalog API that `getVault` / `fetchTokenizedVault`
+ * (and the other `fetchAugustPublic` callers) read from. Defaults to the
+ * compiled-in prod base (`https://api.augustdigital.io/api/v1`); pass `null`
+ * (or call with no arguments) to clear.
+ *
+ * Intended for non-prod deployments that run against an ISOLATED backend
+ * (e.g. a staging API): set it once at construction via
+ * `IAugustBase.publicApiBaseUrl` so a staging-only vault resolves. Production
+ * leaves it unset, so behaviour is unchanged.
+ *
+ * This is a process-global override on the fetcher helpers. The SDK constructor
+ * calls it on EVERY instantiation (with `null` when `publicApiBaseUrl` is
+ * omitted), so the last `AugustSDK` instantiated is authoritative — a prod
+ * instance resets it to the default even after a prior staging instance set it.
+ * An invalid or non-http(s) URL is treated as "no override": it RESETS to the
+ * compiled-in default (warned) rather than retaining a prior value, so a bad env
+ * value can neither break fetches nor silently leave a previous instance's base
+ * in place.
+ *
+ * Whenever the effective base CHANGES, the shared public-response cache is
+ * cleared, so catalog data fetched from the previous backend is never served for
+ * the new one (e.g. a prod-cached vault leaking into a staging instance). Base
+ * changes happen at construction, when the cache is cold, so this is ~free.
+ *
+ * @param url - Absolute http(s) base URL (trailing slash is trimmed). `null`, or
+ *   an invalid / non-http(s) value, resets to the compiled-in public base.
+ */
+function setPublicApiBaseUrl(url = null) {
+    const previous = PUBLIC_API_BASE_OVERRIDE;
+    if (url === null) {
+        PUBLIC_API_BASE_OVERRIDE = null;
+    }
+    else {
+        let parsed = null;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            parsed = null;
+        }
+        if (!parsed ||
+            (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')) {
+            // Reset to the default rather than retaining a stale prior override, so
+            // each construction stays authoritative and a bad env value fails safe to
+            // prod instead of inheriting another instance's base.
+            logger_1.Logger.log.warn('setPublicApiBaseUrl', 'Ignoring invalid/non-http(s) URL; resetting to the default public base', { url });
+            PUBLIC_API_BASE_OVERRIDE = null;
+        }
+        else {
+            // Store WITHOUT a trailing slash: buildAugustUrl concatenates
+            // `${base}${relativeUrl}` (relativeUrl starts with '/'), so a trailing
+            // slash on the base would produce a double slash.
+            PUBLIC_API_BASE_OVERRIDE = url.replace(/\/+$/, '');
+        }
+    }
+    if (PUBLIC_API_BASE_OVERRIDE !== previous) {
+        // The public base moved (or reset). Drop cached public-catalog responses
+        // keyed against the previous base (see fetchTokenizedVault(s) etc.) so they
+        // aren't served for the new backend.
+        cache_1.CACHE.clear();
+    }
+}
+/**
+ * Read the active base for the `public` server — the SDK-level override if set,
+ * otherwise the compiled-in `WEBSERVER_URL.public`.
+ */
+function getPublicApiBaseUrl() {
+    return PUBLIC_API_BASE_OVERRIDE ?? core_2.WEBSERVER_URL.public;
+}
 /**
  * Combine the per-request timeout signal with any caller-supplied signal.
  * Uses `AbortSignal.any` (Node 22+) with a manual relay fallback.
@@ -182,7 +256,12 @@ const PRICE_REQUESTS = new Map();
  */
 function buildAugustUrl(server, relativeUrl) {
     const serverKey = server;
-    const base = core_2.WEBSERVER_URL[serverKey];
+    // The `public` base is overridable (setPublicApiBaseUrl / IAugustBase
+    // .publicApiBaseUrl) so non-prod deployments can point vault-catalog reads at
+    // an isolated backend. Resolved once here via getPublicApiBaseUrl() (single
+    // source of truth), so the origin check below validates against the OVERRIDDEN
+    // origin.
+    const base = serverKey === 'public' ? getPublicApiBaseUrl() : core_2.WEBSERVER_URL[serverKey];
     if (!base) {
         throw new errors_1.AugustValidationError('INVALID_URL', `Unknown August server "${String(server)}". Expected one of: ${Object.keys(core_2.WEBSERVER_URL).join(', ')}`);
     }

package/lib/sdk.d.ts

@@ -15175,7 +15175,7 @@ export declare class AugustBase {
      * @throws If `appName` is missing, malformed, or out of the allowed
      *   length range — see {@link IAugustBase.appName}.
      */
-    constructor({ appName, providers, keys, monitoring, analytics, versionCheck, timeoutMs, }: IAugustBase);
+    constructor({ appName, providers, keys, monitoring, analytics, versionCheck, timeoutMs, publicApiBaseUrl, }: IAugustBase);
     /**
      * Verify API keys and authorize SDK usage.
      * TODO: initialize class with appropriate keys and verify august key
@@ -16818,6 +16818,24 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
       address?: string;
   }): void;
 
+  /**
+   * Decimal precision of the native gas token on every EVM chain this SDK
+   * supports (ETH, Base, Arbitrum, Avalanche, Polygon, BNB, HyperEVM, Unichain,
+   * Mezo, Monad, Plasma, Ink, Flare, Katana, Citrea, Fluent, Tempo).
+   *
+   * All of them use 18-decimal native tokens, so this is a single constant rather
+   * than a per-chain map. It exists because the native token has no ERC-20
+   * `decimals()` to read on-chain: when a subgraph row denominates an amount in
+   * the native token it is flagged with a sentinel address ({@link NATIVE_ADDRESS}
+   * or the zero address) instead of a real contract, and callers must substitute
+   * this value rather than attempting (and failing) a `decimals()` read.
+   *
+   * Non-EVM natives differ (SOL is 9, XLM is 7) and are handled by their own
+   * adapters — those chains never flow through the EVM `decimals()` path this
+   * constant serves.
+   */
+  export declare const EVM_NATIVE_DECIMALS = 18;
+
   /**
    * EVM Adapter for August SDK
    * Supports both ethers Signer/Wallet and wagmi/viem WalletClient
@@ -17654,6 +17672,12 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                options: IVaultBaseOptions;
            }): Promise<INormalizedNumber>;
 
+           /**
+            * Read the active base for the `public` server — the SDK-level override if set,
+            * otherwise the compiled-in `WEBSERVER_URL.public`.
+            */
+           export declare function getPublicApiBaseUrl(): string;
+
            /**
             * Fetch receipt token address from tokenized vault contract.
             * Results are cached to minimize RPC calls.
@@ -18418,6 +18442,25 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 * with different timeouts in the same process.
                 */
                timeoutMs?: number;
+               /**
+                * Override the base URL for the SDK's unauthenticated `public` vault-catalog
+                * API (what `getVault` / `getVaults` / `fetchTokenizedVault` read from).
+                * Defaults to the compiled-in prod base
+                * (`https://api.augustdigital.io/api/v1`) when omitted — so production apps
+                * pass nothing and behaviour is unchanged.
+                *
+                * Set this ONLY for a non-prod deployment that runs against an isolated
+                * backend (e.g. a staging API serving staging-only vaults). Must be an
+                * absolute http(s) URL including any base path, e.g.
+                * `https://api.staging.augustdigital.io/api/v1`. Invalid values are ignored.
+                *
+                * Note: this is a process-global override on the underlying fetcher helpers,
+                * applied on EVERY construction — so the last `AugustSDK` instantiated is
+                * authoritative, and one that omits `publicApiBaseUrl` RESETS to the prod
+                * default. (Stricter than `timeoutMs`, which stays sticky when omitted, since
+                * a stale cross-environment base is higher blast-radius than a stale timeout.)
+                */
+               publicApiBaseUrl?: string;
            }
 
            /** Options for {@link balanceOf}. */
@@ -19775,6 +19818,14 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                owner: IAddress;
                senderAddr?: IAddress;
                amountIn?: string;
+               /**
+                * Deposit asset token address (evm-2 / pre-deposit vaults). The deposited
+                * asset can differ from the vault's underlying and carry different decimals
+                * (e.g. RLUSD at 18 into a 6-decimal sentUSD vault), so `amountIn` must be
+                * normalized against this token's decimals, not the vault's. Absent for
+                * single-asset vaults.
+                */
+               assetIn?: IAddress;
            }
 
            export declare interface ISubgraphFormattedLoan {
@@ -22588,6 +22639,37 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
             declare function setLogger(customLogger: SDKLogger): void;
 
+            /**
+             * Override the base URL used for `WEBSERVER_URL.public` requests — the
+             * unauthenticated vault-catalog API that `getVault` / `fetchTokenizedVault`
+             * (and the other `fetchAugustPublic` callers) read from. Defaults to the
+             * compiled-in prod base (`https://api.augustdigital.io/api/v1`); pass `null`
+             * (or call with no arguments) to clear.
+             *
+             * Intended for non-prod deployments that run against an ISOLATED backend
+             * (e.g. a staging API): set it once at construction via
+             * `IAugustBase.publicApiBaseUrl` so a staging-only vault resolves. Production
+             * leaves it unset, so behaviour is unchanged.
+             *
+             * This is a process-global override on the fetcher helpers. The SDK constructor
+             * calls it on EVERY instantiation (with `null` when `publicApiBaseUrl` is
+             * omitted), so the last `AugustSDK` instantiated is authoritative — a prod
+             * instance resets it to the default even after a prior staging instance set it.
+             * An invalid or non-http(s) URL is treated as "no override": it RESETS to the
+             * compiled-in default (warned) rather than retaining a prior value, so a bad env
+             * value can neither break fetches nor silently leave a previous instance's base
+             * in place.
+             *
+             * Whenever the effective base CHANGES, the shared public-response cache is
+             * cleared, so catalog data fetched from the previous backend is never served for
+             * the new one (e.g. a prod-cached vault leaking into a staging instance). Base
+             * changes happen at construction, when the cache is cold, so this is ~free.
+             *
+             * @param url - Absolute http(s) base URL (trailing slash is trimmed). `null`, or
+             *   an invalid / non-http(s) value, resets to the compiled-in public base.
+             */
+            export declare function setPublicApiBaseUrl(url?: string | null): void;
+
             export declare const setSafeCache: <T>(key: string, value: T) => Promise<void>;
 
             /**

package/lib/services/subgraph/vaults.js

@@ -55,7 +55,60 @@ function alertMissingSubgraphOnce(args) {
 function needsMonadSuffix(chainId, symbol) {
     return chainId === 143 && symbol.toLowerCase() === 'earnausd';
 }
-function transformUserHistory(data, chainId, decimals, poolAddress) {
+/**
+ * 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) => ({
@@ -92,23 +145,33 @@ function transformUserHistory(data, chainId, decimals, poolAddress) {
             timestamp: item.timestamp_,
             decimals: decimals,
         })) || []),
-        ...(data.deposits?.map((item) => ({
-            ...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: 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) {
+function sortUserHistory(data, chainId, decimals, poolAddress, assetDecimals) {
     if (!(data && chainId && decimals))
         return [];
-    return transformUserHistory(data, chainId, decimals, poolAddress).sort((a, b) => Number(a.timestamp_) - Number(b.timestamp_));
+    return transformUserHistory(data, chainId, decimals, poolAddress, assetDecimals).sort((a, b) => Number(a.timestamp_) - Number(b.timestamp_));
 }
 // queries
 const WITHDRAWALS_REQUESTED_QUERY_PROPS = `
@@ -707,9 +770,12 @@ async function getSubgraphUserHistory(user, provider, pool, slackWebookUrl = sla
             return requests;
         }
         const json = (await result.json());
-        // Format data
-        const decimals = await (0, core_1.getDecimals)(provider, pool);
-        const formattedRequests = sortUserHistory(json.data, chainId, decimals, pool);
+        // 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) {
@@ -857,10 +923,13 @@ async function getSubgraphVaultHistory(provider, pool, slackWebookUrl = slack_1.
                 break;
             skip += PAGE_SIZE;
         }
-        // Format data
+        // Format data — vault decimals and per-asset decimals are independent reads.
         const chainId = await (0, core_1.getChainId)(provider);
-        const decimals = await (0, core_1.getDecimals)(provider, pool);
-        const formattedRequests = sortUserHistory(accumulated, chainId, decimals, pool);
+        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) {

package/lib/types/subgraph.d.ts

@@ -35,6 +35,14 @@ export interface ISubgraphDeposit extends ISubgraphBase {
     owner: IAddress;
     senderAddr?: IAddress;
     amountIn?: string;
+    /**
+     * Deposit asset token address (evm-2 / pre-deposit vaults). The deposited
+     * asset can differ from the vault's underlying and carry different decimals
+     * (e.g. RLUSD at 18 into a 6-decimal sentUSD vault), so `amountIn` must be
+     * normalized against this token's decimals, not the vault's. Absent for
+     * single-asset vaults.
+     */
+    assetIn?: IAddress;
 }
 export interface ISubgraphWithdrawRequest extends ISubgraphBase {
     day: string;

package/package.json

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