@augustdigital/sdk 8.9.0 → 8.11.0

package/lib/core/analytics/sanitize.js

@@ -25,6 +25,11 @@ const SENSITIVE_KEYS = [
     'privateKey',
     'mnemonic',
     'seed',
+    // RPC endpoints can carry the API key in the path (e.g. Alchemy `/v2/<key>`),
+    // so a `sorobanRpcUrl` / `rpcUrl` argument must never reach telemetry. Matched
+    // as a substring, so it also covers `sorobanRpcUrls` and snake_case variants.
+    'rpcurl',
+    'rpc_url',
 ];
 /** Regex patterns applied in order to scrub secrets from free-form strings. */
 const STRING_REDACTION_PATTERNS = [
@@ -34,6 +39,9 @@ const STRING_REDACTION_PATTERNS = [
         '$1[REDACTED]',
     ],
     [/(gateway\.thegraph\.com\/api\/)[A-Za-z0-9]{20,}(\/)/g, '$1[REDACTED]$2'],
+    // Provider path-embedded API keys (e.g. Alchemy `…/v2/<key>`, Infura `…/v3/<key>`):
+    // a 16+ char token right after a `/vN/` segment is a key, not a resource path.
+    [/(\/v\d+\/)[A-Za-z0-9_-]{16,}/g, '$1[REDACTED]'],
     [/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, '[REDACTED_JWT]'],
     [/\bnpm_[A-Za-z0-9]{30,}\b/g, '[REDACTED_NPM_TOKEN]'],
     // Stop value match at & # so adjacent query params aren't swallowed.
@@ -172,8 +180,10 @@ function sanitizeArgs(args) {
             return;
         }
         if (typeof arg === 'string') {
-            // Truncate long strings
-            sanitized[key] = arg.length > 100 ? `${arg.substring(0, 100)}...` : arg;
+            // Scrub embedded secrets, then truncate long strings.
+            const scrubbed = sanitizeString(arg);
+            sanitized[key] =
+                scrubbed.length > 100 ? `${scrubbed.substring(0, 100)}...` : scrubbed;
             return;
         }
         if (typeof arg === 'number' || typeof arg === 'boolean') {
@@ -214,8 +224,14 @@ function sanitizeObject(obj, depth = 0) {
                 sanitized[key] = '[REDACTED_HEX]';
                 continue;
             }
+            // Scrub embedded secrets (API keys in URL paths/queries, bearer tokens,
+            // JWTs, …) from free-form values before truncating — key-name matching
+            // alone misses a secret carried inside a value under a benign key.
+            const scrubbedValue = sanitizeString(value);
             sanitized[key] =
-                value.length > 100 ? `${value.substring(0, 100)}...` : value;
+                scrubbedValue.length > 100
+                    ? `${scrubbedValue.substring(0, 100)}...`
+                    : scrubbedValue;
             continue;
         }
         if (typeof value === 'number' || typeof value === 'boolean') {

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.9.0";
+export declare const SDK_VERSION = "8.11.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.9.0';
+exports.SDK_VERSION = '8.11.0';
 //# sourceMappingURL=version.js.map

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

@@ -1,4 +1,4 @@
-import type { ISolanaConfig, IAddress, IChainId, IEnv, IProvidersConfig, IWSMonitorHeaders } from '../types';
+import type { ISolanaConfig, IStellarConfig, IAddress, IChainId, IEnv, IProvidersConfig, IWSMonitorHeaders } from '../types';
 import { type IAnalyticsConfig } from './analytics';
 import { type IVersionCheckConfig } from './version-check';
 interface IKeys {
@@ -38,6 +38,7 @@ export interface IAugustBase {
     appName: string;
     providers?: IProvidersConfig;
     solana?: ISolanaConfig;
+    stellar?: IStellarConfig;
     keys: IKeys;
     monitoring?: IMonitoring;
     /** Analytics configuration. Enabled by default (opt-out model). */

package/lib/core/helpers/chain-error.d.ts

@@ -45,6 +45,7 @@ export declare function isUserRejectionError(error: unknown): boolean;
  * ```
  */
 export declare function isExpectedRevertError(error: unknown): boolean;
+export declare function isInsufficientFundsError(error: unknown): boolean;
 /**
  * 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`

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isUserRejectionError = isUserRejectionError;
 exports.isExpectedRevertError = isExpectedRevertError;
+exports.isInsufficientFundsError = isInsufficientFundsError;
 exports.logChainError = logChainError;
 const logger_1 = require("../logger");
 /**
@@ -21,6 +22,9 @@ const logger_1 = require("../logger");
  * 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.
+ * 3. **Underfunded sender accounts** — the node rejects the transaction because
+ *    the sender can't cover gas (or, on rollups such as Citrea, the extra L1
+ *    data-availability fee). This is a "top up your wallet" prompt, not a bug.
  *
  * These predicates let call sites demote exactly those cases to `warn` while
  * leaving genuine failures at `error`. They are intentionally dependency-free
@@ -77,6 +81,39 @@ function errorCodes(error) {
     }
     return codes;
 }
+/**
+ * Collect every human-readable message string an error-like value carries,
+ * across the nested locations providers stash them in.
+ *
+ * Why this is separate from {@link errorText}: ethers v6 flattens a rejected
+ * `eth_estimateGas`/`eth_call` to a generic *top-level* `message` (e.g.
+ * `"missing revert data"`) while preserving the node's original JSON-RPC error
+ * one level down at `info.error.message`. The real reason (an insufficient-funds
+ * report, say) is therefore invisible to a top-level `.message` read. We scan
+ * the top-level message plus `error.message`, `info.error.message`,
+ * `cause.message`, and `cause.info.error.message` so a caller catches the reason
+ * whether it holds the raw provider error or an SDK error that wrapped it as
+ * `cause`.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns Every non-empty message string found (possibly empty array).
+ */
+function nestedMessages(error) {
+    const out = [];
+    const push = (value) => {
+        if (typeof value === 'string' && value.length > 0)
+            out.push(value);
+    };
+    push(errorText(error));
+    if (error && typeof error === 'object') {
+        const e = error;
+        push(e.error?.message);
+        push(e.info?.error?.message);
+        push(e.cause?.message);
+        push(e.cause?.info?.error?.message);
+    }
+    return out;
+}
 /**
  * Is this error a wallet/user rejection of a transaction or signature request?
  *
@@ -143,6 +180,65 @@ function isExpectedRevertError(error) {
         msg.includes('call revert exception') ||
         msg.includes('reverted'));
 }
+/**
+ * Is this error the chain node reporting that the sender can't afford the
+ * transaction's gas/fee — i.e. the account needs topping up, not a defect?
+ *
+ * This is distinct from a contract revert, and easy to misclassify. When the
+ * node rejects `eth_estimateGas` for an underfunded account, ethers v6 discards
+ * the node's reason and surfaces a generic `CALL_EXCEPTION` / `"missing revert
+ * data"` at the top level — which {@link isExpectedRevertError} matches. The
+ * real reason survives only in the nested JSON-RPC error, so this predicate
+ * scans there (via `nestedMessages`). On a write path, check this **before**
+ * {@link isExpectedRevertError}, or a genuine funds shortfall reads as a benign
+ * revert.
+ *
+ * Matching is anchored to the node's pre-execution funds-check phrasings (see
+ * `INSUFFICIENT_FUNDS_PHRASES`), each of which carries a `for <purpose>`
+ * qualifier — `insufficient funds for gas`, `insufficient funds for transfer`,
+ * `not enough funds for L1 fee` (Citrea's data-availability fee), etc. This is
+ * deliberately narrower than a bare `"insufficient funds"` substring: a
+ * *contract revert reason* that merely contains the word "funds" (e.g.
+ * `execution reverted: insufficient funds in pool`) must stay a genuine failure,
+ * not be demoted to an ACCOUNT_NOT_FUNDED "top up gas" prompt.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure is an unfunded/underfunded sender account.
+ *
+ * @example
+ * ```ts
+ * try { await vault.requestRedeem(...); }
+ * catch (e) {
+ *   if (isInsufficientFundsError(e))
+ *     throw new AugustValidationError(
+ *       'ACCOUNT_NOT_FUNDED',
+ *       'Add gas to continue',
+ *       { cause: e },
+ *     );
+ *   throw e;
+ * }
+ * ```
+ */
+/**
+ * The node pre-execution funds-check phrasings {@link isInsufficientFundsError}
+ * recognises, lower-cased. Each keeps the `for <purpose>` qualifier so the match
+ * is anchored to a funding rejection and can't be tripped by a contract revert
+ * reason that merely mentions "funds". `insufficient funds for gas` covers the
+ * geth/reth `"... for gas * price + value"` message; `not enough funds for l1
+ * fee` is the rollup (Citrea) data-availability-fee shortfall.
+ */
+const INSUFFICIENT_FUNDS_PHRASES = [
+    'insufficient funds for gas',
+    'insufficient funds for transfer',
+    'insufficient funds for intrinsic transaction cost',
+    'not enough funds for l1 fee',
+];
+function isInsufficientFundsError(error) {
+    return nestedMessages(error).some((raw) => {
+        const msg = raw.toLowerCase();
+        return INSUFFICIENT_FUNDS_PHRASES.some((phrase) => msg.includes(phrase));
+    });
+}
 /**
  * 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`

package/lib/main.js

@@ -108,7 +108,12 @@ class AugustSDK extends core_1.AugustBase {
             (0, analytics_1.instrumentClass)(this.solana, () => core_1.SPECIAL_CHAINS.solana.chainId);
         }
         this.sui = new sui_1.default();
-        this.stellar = new stellar_1.default();
+        // @stellar: mirror the Solana injection — the consumer may supply a keyed
+        // Soroban RPC (e.g. Alchemy) via `baseConfig.stellar`; otherwise the adapter
+        // uses its built-in public endpoints. Endpoint is injected, not hardcoded.
+        this.stellar = new stellar_1.default(baseConfig.stellar?.network, {
+            sorobanRpcUrl: baseConfig.stellar?.rpcUrl,
+        });
         this.vaults = new vaults_1.AugustVaults(baseConfig, this.solana, this.sui);
         this.subaccounts = new sub_accounts_1.AugustSubAccounts(baseConfig);
         this.api = new api_1.AugustApi(baseConfig);

package/lib/modules/vaults/getters.js

@@ -1058,7 +1058,11 @@ async function getVaultPositions({ vault, wallet, solanaWallet, stellarWallet, o
                     let balance = (0, core_1.toNormalizedBn)(0);
                     if (stellarWallet && (0, utils_3.isStellarAddress)(stellarWallet)) {
                         const stellarNetwork = v.stellar_vault_metadata?.network_name ?? 'mainnet';
-                        const position = await StellarGetters.getStellarUserPosition(v.address, stellarWallet, stellarNetwork);
+                        // Only use the configured RPC override for its own network.
+                        const stellarOverrideRpcUrl = options.stellarRpc?.network === stellarNetwork
+                            ? options.stellarRpc.rpcUrl
+                            : undefined;
+                        const position = await StellarGetters.getStellarUserPosition(v.address, stellarWallet, stellarNetwork, stellarOverrideRpcUrl);
                         if (position && !position.decimalsFromFallback) {
                             balance = (0, core_1.toNormalizedBn)(BigInt(position.shares), position.decimals);
                         }

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

@@ -23,6 +23,12 @@ export declare class AugustVaults extends AugustBase {
     private solanaService;
     private suiService;
     private headers;
+    /**
+     * Consumer-supplied Soroban RPC override for Stellar vault reads, with the
+     * network it was configured for so it's only applied to matching-network
+     * vaults (see `IVaultBaseOptions.stellarRpc`).
+     */
+    private _stellarRpc?;
     constructor(baseConfig: IAugustBase, solana: SolanaAdapter, sui: SuiAdapter);
     /**
      * @description deposit underlying token into the specified pool with adapter support. This is for when we cannot pass in a signer in sdk and need to do so as an arg

package/lib/modules/vaults/main.js

@@ -74,10 +74,23 @@ class AugustVaults extends core_1.AugustBase {
     solanaService;
     suiService;
     headers = null;
+    /**
+     * Consumer-supplied Soroban RPC override for Stellar vault reads, with the
+     * network it was configured for so it's only applied to matching-network
+     * vaults (see `IVaultBaseOptions.stellarRpc`).
+     */
+    _stellarRpc;
     constructor(baseConfig, solana, sui) {
         super(baseConfig);
         this.solanaService = solana;
         this.suiService = sui || new sui_1.default();
+        // Network defaults to mainnet, matching the StellarAdapter constructor.
+        this._stellarRpc = baseConfig.stellar?.rpcUrl
+            ? {
+                rpcUrl: baseConfig.stellar.rpcUrl,
+                network: baseConfig.stellar.network ?? 'mainnet',
+            }
+            : undefined;
         this.headers = {
             'x-environment': this.monitoring?.['x-environment'],
             'x-user-id': this.monitoring?.['x-user-id'],
@@ -166,6 +179,7 @@ class AugustVaults extends core_1.AugustBase {
                 options: {
                     rpcUrl,
                     solanaService: this.solanaService,
+                    stellarRpc: this._stellarRpc,
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                     subgraphKey: this.keys?.graph,
@@ -243,6 +257,7 @@ class AugustVaults extends core_1.AugustBase {
                 options: {
                     rpcUrl: this.providers?.[v.chain],
                     solanaService: this.solanaService,
+                    stellarRpc: this._stellarRpc,
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                     subgraphKey: this.keys?.graph,
@@ -316,6 +331,7 @@ class AugustVaults extends core_1.AugustBase {
                     ? this.providers?.[chainId]
                     : this.activeNetwork?.rpcUrl,
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
@@ -340,6 +356,7 @@ class AugustVaults extends core_1.AugustBase {
                         ? this.providers?.[chainId]
                         : this.activeNetwork?.rpcUrl,
                     solanaService: this.solanaService,
+                    stellarRpc: this._stellarRpc,
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                     subgraphKey: this.keys?.graph,
@@ -385,6 +402,7 @@ class AugustVaults extends core_1.AugustBase {
             subgraphKey: this.keys?.graph,
             chainId: chainId,
             solanaService: this.solanaService,
+            stellarRpc: this._stellarRpc,
             headers: this.headers,
         });
         return vaultResponse;
@@ -416,6 +434,7 @@ class AugustVaults extends core_1.AugustBase {
             subgraphKey: this.keys?.graph,
             chainId: chainId,
             solanaService: this.solanaService,
+            stellarRpc: this._stellarRpc,
             headers: this.headers,
         });
         return vaultResponse;
@@ -447,6 +466,7 @@ class AugustVaults extends core_1.AugustBase {
                     ? this.providers?.[chainId]
                     : this.activeNetwork?.rpcUrl,
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
@@ -527,6 +547,7 @@ class AugustVaults extends core_1.AugustBase {
                     ? this.providers?.[chainId]
                     : this.activeNetwork?.rpcUrl,
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
@@ -611,6 +632,7 @@ class AugustVaults extends core_1.AugustBase {
                         ? this.providers?.[chainId]
                         : this.activeNetwork?.rpcUrl,
                     solanaService: this.solanaService,
+                    stellarRpc: this._stellarRpc,
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                     subgraphKey: this.keys?.graph,
@@ -632,6 +654,7 @@ class AugustVaults extends core_1.AugustBase {
                 options: {
                     rpcUrl: this.providers?.[v.chain],
                     solanaService: this.solanaService,
+                    stellarRpc: this._stellarRpc,
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                     subgraphKey: this.keys?.graph,
@@ -667,6 +690,7 @@ class AugustVaults extends core_1.AugustBase {
             options: {
                 rpcUrl: this.providers?.[v.chain],
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
@@ -706,6 +730,10 @@ class AugustVaults extends core_1.AugustBase {
                 chainId: _chainId,
                 type: h.type,
                 transactionHash: h.transactionHash_,
+                // Deposit rows on multi-asset (pre-deposit) vaults carry the actual
+                // deposited token address; propagate it so consumers render the right
+                // asset symbol instead of guessing the vault's first deposit asset.
+                assetIn: h.assetIn,
             }));
         }
         // Helper function to fetch history for a vault
@@ -826,6 +854,7 @@ class AugustVaults extends core_1.AugustBase {
                     ? this.providers?.[chainId]
                     : this.requireActiveNetwork().rpcUrl,
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
@@ -851,6 +880,7 @@ class AugustVaults extends core_1.AugustBase {
                     ? this.providers?.[chainId]
                     : this.requireActiveNetwork().rpcUrl,
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
@@ -1033,6 +1063,7 @@ class AugustVaults extends core_1.AugustBase {
                 rpcUrl: rpcUrl,
                 chainId: resolvedChainId,
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
@@ -1056,6 +1087,7 @@ class AugustVaults extends core_1.AugustBase {
             options: {
                 rpcUrl: rpcUrl,
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
@@ -1103,6 +1135,7 @@ class AugustVaults extends core_1.AugustBase {
                         ? this.providers?.[chainId]
                         : rpcUrl || this.requireActiveNetwork().rpcUrl,
                     solanaService: this.solanaService,
+                    stellarRpc: this._stellarRpc,
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                     subgraphKey: this.keys?.graph,
@@ -1376,6 +1409,7 @@ class AugustVaults extends core_1.AugustBase {
             options: {
                 rpcUrl: chainId ? this.providers?.[chainId] : this.activeNetwork.rpcUrl,
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,
@@ -1428,6 +1462,7 @@ class AugustVaults extends core_1.AugustBase {
             options: {
                 rpcUrl,
                 solanaService: this.solanaService,
+                stellarRpc: this._stellarRpc,
                 env: this.monitoring?.env,
                 augustKey: this.keys?.august,
                 subgraphKey: this.keys?.graph,

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

@@ -1,5 +1,5 @@
 import type { Connection } from '@solana/web3.js';
-import type { IAddress, IEnv, IWSMonitorHeaders } from '../../types';
+import type { IAddress, IEnv, IStellarNetwork, IWSMonitorHeaders } from '../../types';
 /**
  * Structural interface for the Solana adapter surface used by vault operations.
  * Avoids importing the concrete SolanaAdapter class to prevent circular dependencies.
@@ -40,6 +40,16 @@ export interface IVaultBaseOptions {
     subgraphKey?: string;
     chainId?: number;
     solanaService?: ISolanaService;
+    /**
+     * Optional Soroban RPC override (e.g. a keyed Alchemy URL) for Stellar vault
+     * reads, threaded from the SDK's `stellar` config. Carries the network it was
+     * configured for so it is only applied to matching-network vaults — a testnet
+     * override must not be used for a mainnet read. Unset → built-in endpoints.
+     */
+    stellarRpc?: {
+        rpcUrl: string;
+        network: IStellarNetwork;
+    };
     headers?: IWSMonitorHeaders;
     /**
      * Portfolio mode: when true, the per-vault EVM getter does NOT null out a

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

@@ -185,6 +185,39 @@ async function tryRecoverTxHash(error, signer, wait) {
     }
     return txHash;
 }
+/**
+ * Rethrow a caught write-path error as a typed {@link AugustValidationError}
+ * when it is the chain node reporting the sender can't afford the transaction's
+ * gas/fee (see {@link isInsufficientFundsError}).
+ *
+ * Why: for an underfunded account ethers surfaces an opaque `CALL_EXCEPTION` /
+ * "missing revert data" that gives the caller no stable way to tell "user needs
+ * gas" apart from a genuine on-chain failure. Converting it to the
+ * `ACCOUNT_NOT_FUNDED` code lets a consuming UI branch on `err.code` (e.g. show
+ * a "top up to cover network fees" prompt) instead of string-matching. Every
+ * write path shares this so the classification is identical across
+ * deposit/redeem/approve rather than drifting per call site.
+ *
+ * A no-op when `isInsufficient` is `false`, so callers fall through to their
+ * existing handling unchanged. The caller passes the already-computed
+ * classification (it also feeds the telemetry-demotion decision) so
+ * {@link isInsufficientFundsError} runs once per catch, not twice.
+ *
+ * @param isInsufficient - Result of {@link isInsufficientFundsError} for
+ *   `error`, computed once by the caller and shared with the benign-log flag.
+ * @param operation - Human-readable label for the attempted write (e.g.
+ *   `'Request redeem'`), used verbatim in the thrown error's message.
+ * @param error - The caught value, of unknown type, preserved as the thrown
+ *   error's `cause`.
+ * @param context - Structured context attached to the thrown error for logging.
+ * @throws {AugustValidationError} with code `ACCOUNT_NOT_FUNDED` when
+ *   `isInsufficient` is `true`.
+ */
+function throwIfInsufficientFunds(isInsufficient, operation, error, context) {
+    if (!isInsufficient)
+        return;
+    throw new core_1.AugustValidationError('ACCOUNT_NOT_FUNDED', `${operation} failed: insufficient native balance to cover gas/network fees`, { cause: error, context });
+}
 async function approveCore(signer, options) {
     const { wallet, target, wait, amount, depositAsset } = options;
     const [goodWallet, goodPool] = [
@@ -293,7 +326,12 @@ async function approveCore(signer, options) {
             throw e;
         // A user declining the approval in their wallet is product behaviour, not
         // an SDK fault — demote it to a breadcrumb so it doesn't bill as an issue.
-        (0, core_1.logChainError)('vaultApprove', e, (0, core_1.isUserRejectionError)(e), {
+        const insufficientFunds = (0, core_1.isInsufficientFundsError)(e);
+        (0, core_1.logChainError)('vaultApprove', e, (0, core_1.isUserRejectionError)(e) || insufficientFunds, {
+            target,
+            amount,
+        });
+        throwIfInsufficientFunds(insufficientFunds, 'Approval', e, {
             target,
             amount,
         });
@@ -601,7 +639,13 @@ async function vaultDeposit(signer, options) {
         if (e instanceof core_1.AugustSDKError)
             throw e;
         // User-cancelled deposits are normal; only genuine failures stay at error.
-        (0, core_1.logChainError)('deposit', e, (0, core_1.isUserRejectionError)(e), {
+        const insufficientFunds = (0, core_1.isInsufficientFundsError)(e);
+        (0, core_1.logChainError)('deposit', e, (0, core_1.isUserRejectionError)(e) || insufficientFunds, {
+            target,
+            amount,
+            depositAsset,
+        });
+        throwIfInsufficientFunds(insufficientFunds, 'Deposit', e, {
             target,
             amount,
             depositAsset,
@@ -754,7 +798,12 @@ async function vaultRequestRedeem(signer, options) {
         if (e instanceof core_1.AugustSDKError)
             throw e;
         // User-cancelled redeem requests are normal; only genuine failures stay at error.
-        (0, core_1.logChainError)('requestRedeem', e, (0, core_1.isUserRejectionError)(e), {
+        const insufficientFunds = (0, core_1.isInsufficientFundsError)(e);
+        (0, core_1.logChainError)('requestRedeem', e, (0, core_1.isUserRejectionError)(e) || insufficientFunds, {
+            target,
+            amount,
+        });
+        throwIfInsufficientFunds(insufficientFunds, 'Request redeem', e, {
             target,
             amount,
         });
@@ -801,7 +850,15 @@ async function vaultRedeem(signer, options) {
         if (e instanceof core_1.AugustSDKError)
             throw e;
         // User-cancelled redeems are normal; only genuine failures stay at error.
-        (0, core_1.logChainError)('redeem', e, (0, core_1.isUserRejectionError)(e), {
+        const insufficientFunds = (0, core_1.isInsufficientFundsError)(e);
+        (0, core_1.logChainError)('redeem', e, (0, core_1.isUserRejectionError)(e) || insufficientFunds, {
+            target,
+            year,
+            month,
+            day,
+            receiverIndex,
+        });
+        throwIfInsufficientFunds(insufficientFunds, 'Redeem', e, {
             target,
             year,
             month,
@@ -899,7 +956,13 @@ async function depositNative(signer, options) {
         if (e instanceof core_1.AugustSDKError)
             throw e;
         // User-cancelled native deposits are normal; only genuine failures stay at error.
-        (0, core_1.logChainError)('depositNative', e, (0, core_1.isUserRejectionError)(e), {
+        const insufficientFunds = (0, core_1.isInsufficientFundsError)(e);
+        (0, core_1.logChainError)('depositNative', e, (0, core_1.isUserRejectionError)(e) || insufficientFunds, {
+            wrapperAddress,
+            receiver,
+            amount,
+        });
+        throwIfInsufficientFunds(insufficientFunds, 'Deposit native', e, {
             wrapperAddress,
             receiver,
             amount,
@@ -978,7 +1041,14 @@ async function rwaRedeemAsset(signer, options) {
         if (e instanceof core_1.AugustSDKError)
             throw e;
         // User-cancelled RWA redeems are normal; only genuine failures stay at error.
-        (0, core_1.logChainError)('rwaRedeemAsset', e, (0, core_1.isUserRejectionError)(e), {
+        const insufficientFunds = (0, core_1.isInsufficientFundsError)(e);
+        (0, core_1.logChainError)('rwaRedeemAsset', e, (0, core_1.isUserRejectionError)(e) || insufficientFunds, {
+            target,
+            asset,
+            amount,
+            minOut,
+        });
+        throwIfInsufficientFunds(insufficientFunds, 'RWA redeem', e, {
             target,
             asset,
             amount,