@augustdigital/sdk 8.24.0 → 8.26.0

package/lib/modules/vaults/main.js

@@ -53,6 +53,7 @@ __exportStar(require("./getters"), exports);
  * AugustVaults class
  */
 const fetcher_1 = require("./fetcher");
+const web3_1 = require("../../core/constants/web3");
 const ethers_1 = require("ethers");
 const getters_1 = require("./getters");
 const vaults_1 = require("../../services/subgraph/vaults");
@@ -152,22 +153,54 @@ class AugustVaults extends core_1.AugustBase {
         const vaultsPerChainId = options?.chainIds
             ? vaultsPerAvailableProviders.filter((v) => options.chainIds.includes(v.chain))
             : vaultsPerAvailableProviders;
-        // Fetch and transform (filter for active status)
-        const emberVaults = await this.suiService.getEmberVaults({
-            status: 'active',
+        // Skip vaults the post-enrichment filter (filterVaultsIntelligently +
+        // the includeClosed gate below) is guaranteed to drop, BEFORE paying
+        // their per-vault enrichment. `status` / `is_visible` land on the
+        // enriched vault verbatim from this backend row, so filtering on the row
+        // is exactly equivalent to filtering on the enriched result — it just
+        // saves the on-chain reads (and their retry backoff) for vaults that can
+        // never appear in the output. The post-filter below is kept unchanged as
+        // the authority on the final shape.
+        const enrichableVaults = vaultsPerChainId.filter((v) => {
+            const status = v?.status || 'unknown';
+            if (status === 'closed')
+                return !!options?.includeClosed;
+            if (status === 'active')
+                return true;
+            // Mirrors filterVaultsIntelligently: an unknown-status vault survives
+            // only through the invisible bucket; a visible one lands in `failed`.
+            return !(v?.is_visible ?? true);
         });
-        const activeEmberVaults = Array.isArray(emberVaults)
-            ? emberVaults.filter((v) => v?.status === 'active')
-            : [];
-        const whitelistedEmberVaults = activeEmberVaults.filter((v) => {
-            if (!v?.address)
-                return false;
-            const normalizedAddress = v.address.toLowerCase().trim();
-            return constants_1.ALLOWED_SUI_VAULT_ADDRESSES.includes(normalizedAddress);
-        });
-        const transformedVaults = this.suiService.transformEmberVaultsToIVaults(whitelistedEmberVaults);
+        // The backend row for each vault about to be enriched. getVault re-uses
+        // it instead of re-fetching `GET /tokenized_vault/{address}` per vault —
+        // the row came from the same list response (same load flags), so this is
+        // a pure de-duplication of backend traffic, not a freshness change.
+        const vaultRowsByAddress = new Map(enrichableVaults.map((row) => [String(row.address).toLowerCase(), row]));
+        // Ember (Sui) vaults come from a third-party API and are appended to the
+        // non-wallet result. When the caller scopes the query with `chainIds` and
+        // that scope excludes Sui, skip the fetch entirely — previously it was
+        // awaited unconditionally, so a slow Bluefin endpoint stalled even
+        // EVM-only and Solana/Stellar-only queries.
+        const includeSuiVaults = !options?.chainIds || options.chainIds.includes(web3_1.SUI_CHAIN_ID);
+        let transformedVaults = [];
+        if (includeSuiVaults) {
+            // Fetch and transform (filter for active status)
+            const emberVaults = await this.suiService.getEmberVaults({
+                status: 'active',
+            });
+            const activeEmberVaults = Array.isArray(emberVaults)
+                ? emberVaults.filter((v) => v?.status === 'active')
+                : [];
+            const whitelistedEmberVaults = activeEmberVaults.filter((v) => {
+                if (!v?.address)
+                    return false;
+                const normalizedAddress = v.address.toLowerCase().trim();
+                return constants_1.ALLOWED_SUI_VAULT_ADDRESSES.includes(normalizedAddress);
+            });
+            transformedVaults = this.suiService.transformEmberVaultsToIVaults(whitelistedEmberVaults);
+        }
         // Use comprehensive vault fetching for maximum coverage
-        const vaultFetchResult = await (0, fetcher_1.fetchVaultsComprehensive)(vaultsPerChainId, async (vault) => {
+        const vaultFetchResult = await (0, fetcher_1.fetchVaultsComprehensive)(enrichableVaults, async (vault) => {
             // Handle fallback RPC if provided
             const rpcUrl = vault.fallbackRpc || this.providers?.[vault.chain];
             // Closed vaults have no live loans/allocations. In portfolio mode,
@@ -188,6 +221,9 @@ class AugustVaults extends core_1.AugustBase {
                 vault: vault.address,
                 loans: shouldFetchLoans,
                 allocations: shouldFetchAllocations,
+                // Re-use the backend row from the list response instead of letting
+                // getVault re-fetch it per vault (an N+1 against the backend).
+                tokenizedVault: vaultRowsByAddress.get(String(vault.address).toLowerCase()),
                 options: {
                     rpcUrl,
                     solanaService: this.solanaService,
@@ -204,8 +240,8 @@ class AugustVaults extends core_1.AugustBase {
             });
             return v;
         }, {
-            maxRetries: 5,
-            baseDelay: 2000,
+            maxRetries: options?.maxRetries ?? 5,
+            baseDelay: options?.baseDelay ?? 2000,
             batchSize: 15,
             parallelLimit: 8,
             includeClosed: true,
@@ -257,8 +293,8 @@ class AugustVaults extends core_1.AugustBase {
             ...(options?.includeClosed ? filteredResults.closed : []),
             ...filteredResults.invisible,
         ];
-        if ((options.wallet && (0, ethers_1.isAddress)(options.wallet)) ||
-            (options.solanaWallet &&
+        if ((options?.wallet && (0, ethers_1.isAddress)(options.wallet)) ||
+            (options?.solanaWallet &&
                 utils_1.SolanaUtils.isSolanaAddress(options.solanaWallet))) {
             // Batch the per-vault balanceOf/lagDuration reads (Multicall3, grouped
             // by chain) before fanning out — vaults the batch couldn't serve fall
@@ -294,7 +330,7 @@ class AugustVaults extends core_1.AugustBase {
                 position: positions?.find((pos) => pos.vault?.toLowerCase() === r.address?.toLowerCase()) || null,
             }));
         }
-        if (options.wallet && !(0, ethers_1.isAddress)(options.wallet)) {
+        if (options?.wallet && !(0, ethers_1.isAddress)(options.wallet)) {
             core_1.Logger.log.warn('getVaults:invalid_wallet', options.wallet);
         }
         // console.log(`#getVaults:`, filteredResponses);

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

@@ -69,3 +69,55 @@ export interface IVaultCustomOptions {
     solanaWallet?: string;
     stellarWallet?: string;
 }
+/**
+ * Options accepted by `getVaults` — on both the `AugustSDK` facade and the
+ * underlying `AugustVaults` module. Defined once so the two signatures cannot
+ * drift (the facade previously declared a narrower inline type that rejected
+ * documented options like `includeClosed` at compile time).
+ */
+export interface IGetVaultsOptions extends IVaultCustomOptions {
+    chainIds?: number[];
+    headers?: IWSMonitorHeaders;
+    loadSubaccounts?: boolean;
+    loadSnapshots?: boolean;
+    /**
+     * Portfolio mode: include closed vaults in the result.
+     *
+     * By default (`false`) closed vaults are excluded, so marketplace /
+     * discovery callers never receive a `status: 'closed'` vault. When set,
+     * closed vaults are returned regardless of `is_visible` (closed +
+     * invisible vaults bucket as closed), so a consumer joining user
+     * positions can render a position held in a closed vault on the
+     * portfolio page.
+     *
+     * In this mode, loans/allocations enrichment is also skipped for closed
+     * vaults: they have none, and the per-vault enrichment
+     * (`getVault` → `getVaultAllocations`) otherwise re-throws when a closed
+     * vault has no live strategy/debank data or no subaccounts, which would
+     * land the vault in the `failed` bucket and silently drop it before it
+     * reaches the filter. Skipping enrichment lets the vault survive on its
+     * backend metadata + base on-chain read.
+     *
+     * @default false
+     */
+    includeClosed?: boolean;
+    /**
+     * Maximum primary-fetch attempts per vault before the fallback
+     * strategies (fallback RPCs, minimal fetch, extended retry) run.
+     * Attempt `n` waits `baseDelay * 2^(n-1)` ms before retrying, so the
+     * default (5 attempts, 2000 ms base) can spend up to 30s of backoff on
+     * a single persistently-failing vault. Callers racing this method
+     * against their own timeout should lower it (e.g. `2`) so one flaky
+     * vault cannot exhaust the whole budget.
+     *
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * Base backoff delay in **milliseconds** for the per-vault retry
+     * schedule (see `maxRetries`).
+     *
+     * @default 2000
+     */
+    baseDelay?: number;
+}

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

@@ -1,4 +1,4 @@
-import type { IAddress, IContractRunner, INormalizedNumber, IPoolFunctions, ITokenizedVault, IVault, IVaultFreshness } from '../../types';
+import type { IAddress, IContractRunner, INormalizedNumber, IPoolFunctions, ITokenizedVault, IVault, IVaultFreshness, IVaultVersion } from '../../types';
 import { ethers } from 'ethers';
 import type { WalletClient } from 'viem';
 /**
@@ -50,9 +50,14 @@ export declare function getVaultRewards(tokenizedVault: ITokenizedVault): {
  * @param provider - The provider
  * @param vaultAddress - The vault address
  * @param totalAssets - The total assets of the vault
+ * @param knownVersion - Optional pre-resolved vault version. Callers that
+ *   already hold the backend row (e.g. `buildFormattedVault`) pass it so this
+ *   function doesn't re-fetch `GET /tokenized_vault/{address}` — and with the
+ *   API's default load flags at that, a heavier payload on a different cache
+ *   key than the caller's own fetch — just to dispatch on the version.
  * @returns The idle assets
  */
-export declare function getIdleAssets(provider: IContractRunner, vaultAddress: IAddress, underlying: IAddress, totalAssets: INormalizedNumber): Promise<bigint>;
+export declare function getIdleAssets(provider: IContractRunner, vaultAddress: IAddress, underlying: IAddress, totalAssets: INormalizedNumber, knownVersion?: IVaultVersion): Promise<bigint>;
 export declare function getYieldLastRealizedOn(provider: IContractRunner, vaultAddress: IAddress): Promise<number>;
 /**
  * Format APY data from backend tokenized vault into the unified IVaultApy shape.

package/lib/modules/vaults/utils.js

@@ -133,11 +133,16 @@ function getVaultRewards(tokenizedVault) {
  * @param provider - The provider
  * @param vaultAddress - The vault address
  * @param totalAssets - The total assets of the vault
+ * @param knownVersion - Optional pre-resolved vault version. Callers that
+ *   already hold the backend row (e.g. `buildFormattedVault`) pass it so this
+ *   function doesn't re-fetch `GET /tokenized_vault/{address}` — and with the
+ *   API's default load flags at that, a heavier payload on a different cache
+ *   key than the caller's own fetch — just to dispatch on the version.
  * @returns The idle assets
  */
-async function getIdleAssets(provider, vaultAddress, underlying, totalAssets) {
-    const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vaultAddress))?.[0];
-    const version = (0, vaults_1.getVaultVersionV2)(tokenizedVault);
+async function getIdleAssets(provider, vaultAddress, underlying, totalAssets, knownVersion) {
+    const version = knownVersion ??
+        (0, vaults_1.getVaultVersionV2)((await (0, core_1.fetchTokenizedVault)(vaultAddress))?.[0]);
     let idleAssets;
     switch (version) {
         case 'evm-0': {
@@ -522,7 +527,10 @@ async function buildFormattedVault(provider, tokenizedVault, contractCalls) {
         isDepositPaused: (0, vaults_1.isBadVault)(tokenizedVault.address),
         decimals: contractCalls.decimals,
         isWithdrawalPaused: contractCalls.withdrawalsPaused,
-        idleAssets: (0, core_1.toNormalizedBn)(await getIdleAssets(provider, tokenizedVault.address, contractCalls.asset, contractCalls.totalAssets), Number(contractCalls.decimals)),
+        idleAssets: (0, core_1.toNormalizedBn)(await getIdleAssets(provider, tokenizedVault.address, contractCalls.asset, contractCalls.totalAssets, 
+        // The row is already in hand — don't let getIdleAssets re-fetch it
+        // just to resolve the version.
+        (0, vaults_1.getVaultVersionV2)(tokenizedVault)), Number(contractCalls.decimals)),
     };
     // Version specific logic
     const version = (0, vaults_1.getVaultVersionV2)(tokenizedVault);

package/lib/modules/vaults/write.actions.d.ts

@@ -501,6 +501,10 @@ export declare function depositNativeViaSwapRouter(signer: Signer | Wallet, opti
  *    the chain's whitelisted aggregator, fail-closed on router/selector drift)
  *    bundled into {@link swapAndDeposit}.
  *
+ * An `originCode` is forwarded verbatim to whichever of those three entry points
+ * runs, so a partner's origin fee accrues on every path. Omitting it sends the
+ * all-zero sentinel, which the router reads as "no origin fee".
+ *
  * Side effects: reads tokenized-vault metadata, the vault's reference asset and
  * decimals, and (on the swap path) one Paraswap quote; sends one ERC-20
  * `approve` to the SwapRouter when allowance is short, then the deposit tx.

package/lib/modules/vaults/write.actions.js

@@ -1311,6 +1311,7 @@ async function dispatchViaSwapRouter(args) {
             vault: args.target,
             receiver: sharesReceiver,
             amount: amountRaw,
+            originCode: args.originCode,
             wait: args.wait,
         });
     }
@@ -1323,6 +1324,7 @@ async function dispatchViaSwapRouter(args) {
             receiver: sharesReceiver,
             asset: args.actualDepositAsset,
             amount: amountRaw,
+            originCode: args.originCode,
             wait: args.wait,
         });
     }
@@ -1389,6 +1391,7 @@ async function dispatchViaSwapRouter(args) {
                 payload: quote.payload,
             },
         ],
+        originCode: args.originCode,
         wait: args.wait,
     });
 }
@@ -1638,6 +1641,10 @@ async function depositNativeViaSwapRouter(signer, options) {
  *    the chain's whitelisted aggregator, fail-closed on router/selector drift)
  *    bundled into {@link swapAndDeposit}.
  *
+ * An `originCode` is forwarded verbatim to whichever of those three entry points
+ * runs, so a partner's origin fee accrues on every path. Omitting it sends the
+ * all-zero sentinel, which the router reads as "no origin fee".
+ *
  * Side effects: reads tokenized-vault metadata, the vault's reference asset and
  * decimals, and (on the swap path) one Paraswap quote; sends one ERC-20
  * `approve` to the SwapRouter when allowance is short, then the deposit tx.
@@ -1664,7 +1671,7 @@ async function depositNativeViaSwapRouter(signer, options) {
  * ```
  */
 async function swapRouterDeposit(signer, options) {
-    const { chainId, vault, depositAsset, amount, receiver, slippageBps, wait } = options;
+    const { chainId, vault, depositAsset, amount, receiver, slippageBps, originCode, wait, } = options;
     if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
         throw new core_1.AugustValidationError('INVALID_ADDRESS', `swapRouterDeposit: invalid vault address "${vault}"`);
     }
@@ -1743,6 +1750,7 @@ async function swapRouterDeposit(signer, options) {
         depositTokenDecimals,
         normalizedAmt,
         slippageBps,
+        originCode,
         wait,
     });
 }