@augustdigital/sdk 8.6.0 → 8.6.1

package/lib/core/analytics/instrumentation.js

@@ -123,15 +123,11 @@ function trackMethodCall(methodName, metrics, args) {
         // Counters: SUM(invocation) → total calls; SUM(error)/SUM(invocation) → error rate.
         sdk.setMeasurement('sdk.method.invocation', 1, 'none');
         sdk.setMeasurement('sdk.method.error', metrics.success ? 0 : 1, 'none');
-        // Update tags for filtering
+        // Only sticky-tag the last method name — useful for attributing errors that fire
+        // outside an active SDK span. sdk.category and sdk.chain are already recorded as
+        // span attributes on each call, so mutating the global scope with them here would
+        // just contaminate subsequent unrelated events with stale values.
         sdk.setTag('sdk.last_method', methodName);
-        if (metrics.category) {
-            sdk.setTag('sdk.category', metrics.category);
-        }
-        if (metrics.chainId !== undefined) {
-            sdk.setTag('sdk.chain', (0, chain_name_1.chainIdToTagValue)(metrics.chainId));
-            sdk.setTag('sdk.last_chainId', metrics.chainId.toString());
-        }
     }
     catch {
         // Silently fail - analytics should never break SDK
@@ -223,9 +219,9 @@ function trackSyncMethodCall(methodName, metrics, args) {
                 ...args,
             },
         });
-        // Counters — sync calls attach to whatever span is active on the scope.
-        sdk.setMeasurement('sdk.method.invocation', 1, 'none');
-        sdk.setMeasurement('sdk.method.error', metrics.success ? 0 : 1, 'none');
+        // Measurements omitted: sync methods have no span of their own, so setMeasurement
+        // would attach to whatever parent transaction happens to be active on the scope,
+        // overwriting its counters. The breadcrumb above already captures success/failure.
         sdk.setTag('sdk.last_sync_method', methodName);
         if (metrics.category) {
             sdk.setTag('sdk.category', metrics.category);

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

@@ -6,7 +6,7 @@ import type { IAnalyticsConfig } from './types';
  * only refresh user identity and the cached API-key hash.
  *
  * @param config - Analytics configuration. Pass `tracesSampleRate` to
- *   override the Phase 1/2 default of `1.0`.
+ *   override the default of `0.1`.
  * @param environment - Current environment (DEV or PROD).
  * @param walletAddress - Optional wallet address for user identification.
  * @param apiKey - Optional API key (hashed for identification).

package/lib/core/analytics/sentry.js

@@ -138,7 +138,7 @@ function createSentrySink() {
  * only refresh user identity and the cached API-key hash.
  *
  * @param config - Analytics configuration. Pass `tracesSampleRate` to
- *   override the Phase 1/2 default of `1.0`.
+ *   override the default of `0.1`.
  * @param environment - Current environment (DEV or PROD).
  * @param walletAddress - Optional wallet address for user identification.
  * @param apiKey - Optional API key (hashed for identification).
@@ -214,17 +214,36 @@ function initializeSentry(config, environment, walletAddress, apiKey, appName) {
         const rawSampleRate = typeof config.tracesSampleRate === 'number' &&
             Number.isFinite(config.tracesSampleRate)
             ? config.tracesSampleRate
-            : 1.0;
+            : 0.1; // Phase 2 default — verified partners can opt into 1.0 explicitly
         const tracesSampleRate = Math.max(0, Math.min(1, rawSampleRate));
         sdk.init({
             dsn: constants_1.SENTRY_DSN,
-            // TODO(post-verified-partner): ramp default down to ~0.1.
             tracesSampleRate,
             enableTracing: true,
             environment: environment.toLowerCase(),
             release: `august-sdk@${getSDKVersion()}`,
             sendDefaultPii: true,
-            integrations: [sdk.captureConsoleIntegration({ levels: ['error'] })],
+            // SDK errors route through Logger.setSentrySink → captureException directly,
+            // so captureConsoleIntegration is redundant here. Omitting it also prevents
+            // consumer app console.error calls from being billed as SDK error events (the
+            // global sdk:'august-digital' tag would otherwise cause them to pass beforeSend).
+            integrations: [],
+            // Drop classes of event that are never SDK signal, as a backstop to the
+            // call-site demotions (see `logChainError` / `isUserRejectionError`).
+            // Scope is deliberately narrow: only categories that are noise in EVERY
+            // code path. Generic contract reverts (`CALL_EXCEPTION` / "missing revert
+            // data") are intentionally NOT listed — a reverted *write* tx is a real
+            // error we keep at `error` level, and only read-path reverts are demoted
+            // (surgically, at the call site).
+            ignoreErrors: [
+                // Wallet user-rejections are normal product behaviour, not an SDK fault.
+                /user rejected/i,
+                /user denied/i,
+                'ACTION_REJECTED',
+                // Local dev/test node leaking into a prod DSN: :8545 is the canonical
+                // Anvil/Hardhat port and is never a production RPC endpoint.
+                /ECONNREFUSED .*:8545/,
+            ],
             beforeSend(event) {
                 // Only send events tagged as SDK-related
                 if (event.tags?.sdk !== 'august-digital') {
@@ -233,7 +252,14 @@ function initializeSentry(config, environment, walletAddress, apiKey, appName) {
                 return event;
             },
             beforeSendTransaction(transaction) {
-                // Always include transactions for performance tracking
+                // Sub-sample the high-frequency network bookkeeping category (switchNetwork,
+                // updateWallet, clearWallet, setSigner) to 10% of whatever tracesSampleRate
+                // already passed — these fire on every wallet/chain update and are low signal
+                // for the partner-usage dashboard relative to read/write calls.
+                if (transaction.tags?.['sdk.category'] === 'network' &&
+                    Math.random() > 0.1) {
+                    return null;
+                }
                 return transaction;
             },
         });

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

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

@@ -0,0 +1,66 @@
+/**
+ * Is this error a wallet/user rejection of a transaction or signature request?
+ *
+ * Detects ethers v6's `ACTION_REJECTED` code, the EIP-1193 `4001`
+ * ("User rejected the request") code (top-level or nested), and the common
+ * human-readable phrasings as a fallback for providers that omit a code.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure was the user declining in their wallet.
+ *
+ * @example
+ * ```ts
+ * try { await vault.deposit(...); }
+ * catch (e) {
+ *   if (isUserRejectionError(e)) return; // user cancelled — not an error
+ *   throw e;
+ * }
+ * ```
+ */
+export declare function isUserRejectionError(error: unknown): boolean;
+/**
+ * Is this error a routine on-chain read revert rather than a real failure?
+ *
+ * Reading a function a contract doesn't implement, or an address that holds no
+ * (or incompatible) bytecode, reverts — a normal outcome when the SDK probes
+ * heterogeneous vaults. Matches ethers' `CALL_EXCEPTION` code and the
+ * message variants emitted by ethers and viem (`missing revert data`,
+ * `execution reverted`, `call revert exception`, and the bare `reverted`
+ * phrasing such as `the contract function "totalAssets" reverted`).
+ *
+ * Scope note: callers apply this on **read** paths only. A reverted *write*
+ * (a tx that failed on-chain) is a genuine error and is intentionally not
+ * demoted by this predicate's use in `write.actions`.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure is an expected/benign contract revert.
+ *
+ * @example
+ * ```ts
+ * try { return await vaultContract.maxDepositAmount(); }
+ * catch (e) {
+ *   logChainError('maxDeposit', e, isExpectedRevertError(e));
+ *   throw e;
+ * }
+ * ```
+ */
+export declare function isExpectedRevertError(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`
+ * (a Sentry breadcrumb that rides along with the next real issue, not a billed
+ * standalone issue); otherwise it is logged at `error` (a Sentry issue). The
+ * caller is still responsible for re-throwing — this only routes telemetry.
+ *
+ * Pass the benign decision explicitly (via {@link isUserRejectionError} or
+ * {@link isExpectedRevertError}) so the call site documents *why* the demotion
+ * is safe and each path opts into only the category that applies to it.
+ *
+ * @param tag - Low-cardinality call-site label (e.g. `'deposit'`), used as the
+ *   Sentry breadcrumb/issue grouping key.
+ * @param error - The caught value, of unknown type.
+ * @param isBenign - `true` to demote to `warn`; `false` to keep at `error`.
+ * @param context - Optional structured context attached to the log entry. It is
+ *   sanitized by the logger before transport.
+ */
+export declare function logChainError(tag: string, error: unknown, isBenign: boolean, context?: Record<string, unknown>): void;

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

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUserRejectionError = isUserRejectionError;
+exports.isExpectedRevertError = isExpectedRevertError;
+exports.logChainError = logChainError;
+const logger_1 = require("../logger");
+/**
+ * Classification of caught chain/RPC/wallet errors so the SDK can decide
+ * whether a failure is worth a standalone Sentry issue or is routine, expected
+ * noise that should ride along as a breadcrumb instead.
+ *
+ * Why this exists: most of the SDK's read/write paths `catch` and re-throw, and
+ * historically logged every caught error at `error` level — which the SDK's
+ * Sentry sink turns into a billed issue (see the severity policy on
+ * `SDKSentrySink` in `core/logger`). Two large, low-signal categories dominate
+ * that volume:
+ *
+ * 1. **User-rejected transactions** — the user clicked "reject" in their wallet.
+ *    This is normal product behaviour, not an SDK fault, yet it fires on every
+ *    cancelled deposit/redeem/approve.
+ * 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.
+ *
+ * These predicates let call sites demote exactly those cases to `warn` while
+ * leaving genuine failures at `error`. They are intentionally dependency-free
+ * (no `ethers`/Sentry imports) so they stay cheap and safe in both browser and
+ * Node, and classify purely by inspecting the error's `code`/`message` shape.
+ *
+ * @module
+ */
+/**
+ * Best-effort message extraction from an unknown thrown value. Reads
+ * `error.message` for `Error` and error-like objects, passes strings through,
+ * and falls back to `String(error)` for everything else. Never throws.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns The error's message text (never `undefined`).
+ */
+function errorText(error) {
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    if (error && typeof error === 'object') {
+        const maybe = error.message;
+        if (typeof maybe === 'string')
+            return maybe;
+    }
+    return String(error);
+}
+/**
+ * Collect the `code` fields an error-like value may carry. Wallet/provider
+ * errors stash their machine-readable code in different places depending on the
+ * stack: ethers sets a top-level string `code` (e.g. `'ACTION_REJECTED'`),
+ * EIP-1193 providers use a numeric `code` (e.g. `4001`), and some wrap the
+ * original under `error`/`info.error`/`cause`. We scan the common locations so
+ * callers needn't know which library produced the error.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns Every string/number `code` found (possibly empty).
+ */
+function errorCodes(error) {
+    const codes = [];
+    if (error && typeof error === 'object') {
+        const e = error;
+        const candidates = [
+            e.code,
+            e.error?.code,
+            e.info?.error?.code,
+            e.cause?.code,
+        ];
+        for (const c of candidates) {
+            if (typeof c === 'string' || typeof c === 'number')
+                codes.push(c);
+        }
+    }
+    return codes;
+}
+/**
+ * Is this error a wallet/user rejection of a transaction or signature request?
+ *
+ * Detects ethers v6's `ACTION_REJECTED` code, the EIP-1193 `4001`
+ * ("User rejected the request") code (top-level or nested), and the common
+ * human-readable phrasings as a fallback for providers that omit a code.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure was the user declining in their wallet.
+ *
+ * @example
+ * ```ts
+ * try { await vault.deposit(...); }
+ * catch (e) {
+ *   if (isUserRejectionError(e)) return; // user cancelled — not an error
+ *   throw e;
+ * }
+ * ```
+ */
+function isUserRejectionError(error) {
+    const codes = errorCodes(error);
+    if (codes.includes('ACTION_REJECTED') || codes.includes(4001))
+        return true;
+    const msg = errorText(error).toLowerCase();
+    return (msg.includes('user rejected') ||
+        msg.includes('user denied') ||
+        msg.includes('rejected the request') ||
+        msg.includes('request rejected'));
+}
+/**
+ * Is this error a routine on-chain read revert rather than a real failure?
+ *
+ * Reading a function a contract doesn't implement, or an address that holds no
+ * (or incompatible) bytecode, reverts — a normal outcome when the SDK probes
+ * heterogeneous vaults. Matches ethers' `CALL_EXCEPTION` code and the
+ * message variants emitted by ethers and viem (`missing revert data`,
+ * `execution reverted`, `call revert exception`, and the bare `reverted`
+ * phrasing such as `the contract function "totalAssets" reverted`).
+ *
+ * Scope note: callers apply this on **read** paths only. A reverted *write*
+ * (a tx that failed on-chain) is a genuine error and is intentionally not
+ * demoted by this predicate's use in `write.actions`.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure is an expected/benign contract revert.
+ *
+ * @example
+ * ```ts
+ * try { return await vaultContract.maxDepositAmount(); }
+ * catch (e) {
+ *   logChainError('maxDeposit', e, isExpectedRevertError(e));
+ *   throw e;
+ * }
+ * ```
+ */
+function isExpectedRevertError(error) {
+    const codes = errorCodes(error);
+    if (codes.includes('CALL_EXCEPTION'))
+        return true;
+    const msg = errorText(error).toLowerCase();
+    return (msg.includes('call_exception') ||
+        msg.includes('missing revert data') ||
+        msg.includes('execution reverted') ||
+        msg.includes('call revert exception') ||
+        msg.includes('reverted'));
+}
+/**
+ * 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`
+ * (a Sentry breadcrumb that rides along with the next real issue, not a billed
+ * standalone issue); otherwise it is logged at `error` (a Sentry issue). The
+ * caller is still responsible for re-throwing — this only routes telemetry.
+ *
+ * Pass the benign decision explicitly (via {@link isUserRejectionError} or
+ * {@link isExpectedRevertError}) so the call site documents *why* the demotion
+ * is safe and each path opts into only the category that applies to it.
+ *
+ * @param tag - Low-cardinality call-site label (e.g. `'deposit'`), used as the
+ *   Sentry breadcrumb/issue grouping key.
+ * @param error - The caught value, of unknown type.
+ * @param isBenign - `true` to demote to `warn`; `false` to keep at `error`.
+ * @param context - Optional structured context attached to the log entry. It is
+ *   sanitized by the logger before transport.
+ */
+function logChainError(tag, error, isBenign, context) {
+    if (isBenign) {
+        // Demote to a breadcrumb: the SDK's Sentry sink forwards `warn` as a
+        // breadcrumb, so this no longer creates its own billed issue while still
+        // preserving the trail if a genuine error follows.
+        logger_1.Logger.log.warn(tag, { message: errorText(error), ...(context ?? {}) });
+        return;
+    }
+    logger_1.Logger.log.error(tag, error, context);
+}
+//# sourceMappingURL=chain-error.js.map

package/lib/core/index.d.ts

@@ -12,6 +12,7 @@ export * from './constants/vaults';
 export * from './constants/swap-router';
 export * from './helpers/web3';
 export * from './helpers/vaults';
+export * from './helpers/chain-error';
 export * from './helpers/core';
 export * from './helpers/adapters';
 export * from './helpers/signer';

package/lib/core/index.js

@@ -28,6 +28,7 @@ __exportStar(require("./constants/vaults"), exports);
 __exportStar(require("./constants/swap-router"), exports);
 __exportStar(require("./helpers/web3"), exports);
 __exportStar(require("./helpers/vaults"), exports);
+__exportStar(require("./helpers/chain-error"), exports);
 __exportStar(require("./helpers/core"), exports);
 __exportStar(require("./helpers/adapters"), exports);
 __exportStar(require("./helpers/signer"), exports);

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

@@ -40,7 +40,7 @@ async function fetchInstantRedemptionFee(signer, options) {
         }
     }
     catch (e) {
-        core_1.Logger.log.error('failed to fetch instant redeem fee', e);
+        (0, core_1.logChainError)('failed to fetch instant redeem fee', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch instant redeem fee for ${target}: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -83,7 +83,7 @@ async function vaultAllowance(signer, options) {
         return normalized;
     }
     catch (e) {
-        core_1.Logger.log.error('allowance', e);
+        (0, core_1.logChainError)('allowance', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch allowance: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -109,7 +109,7 @@ async function sendersWhitelistAddress(signer, options) {
         return whitelistAddress;
     }
     catch (e) {
-        core_1.Logger.log.error('sendersWhitelistAddress', e);
+        (0, core_1.logChainError)('sendersWhitelistAddress', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch senders whitelist address: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -138,7 +138,7 @@ async function isWhitelisted(signer, options) {
         return result;
     }
     catch (e) {
-        core_1.Logger.log.error('isWhitelisted', e);
+        (0, core_1.logChainError)('isWhitelisted', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to check whitelist status: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -183,7 +183,7 @@ async function getDeposited(signer, options) {
         return normalized;
     }
     catch (e) {
-        core_1.Logger.log.error('getDeposited', e);
+        (0, core_1.logChainError)('getDeposited', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch deposited amount: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -232,7 +232,7 @@ async function getRemainingAllocations(signer, options) {
         return normalized;
     }
     catch (e) {
-        core_1.Logger.log.error('getRemainingAllocations', e);
+        (0, core_1.logChainError)('getRemainingAllocations', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch remaining allocations: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -263,7 +263,11 @@ async function previewRwaRedemption(signer, options) {
         return normalized;
     }
     catch (e) {
-        core_1.Logger.log.error('previewRwaRedemption', e, { target, asset, amount });
+        (0, core_1.logChainError)('previewRwaRedemption', e, (0, core_1.isExpectedRevertError)(e), {
+            target,
+            asset,
+            amount,
+        });
         throw new Error(`Preview RWA redemption failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -354,7 +358,10 @@ async function previewDeposit(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('previewDeposit', e, { vault, amount: amount.toString() });
+        (0, core_1.logChainError)('previewDeposit', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            amount: amount.toString(),
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `previewDeposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, amount: amount.toString() } });
     }
 }
@@ -410,7 +417,7 @@ async function previewRedeem(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('previewRedeem', e, {
+        (0, core_1.logChainError)('previewRedeem', e, (0, core_1.isExpectedRevertError)(e), {
             vault,
             shares: shares.toString(),
         });
@@ -480,7 +487,11 @@ async function allowance(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('allowance', e, { vault, owner, asset });
+        (0, core_1.logChainError)('allowance', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            owner,
+            asset,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `allowance failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, owner, asset } });
     }
 }
@@ -521,7 +532,7 @@ async function balanceOf(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('balanceOf', e, { asset, owner });
+        (0, core_1.logChainError)('balanceOf', e, (0, core_1.isExpectedRevertError)(e), { asset, owner });
         throw new core_1.AugustSDKError('UNKNOWN', `balanceOf failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { asset, owner } });
     }
 }
@@ -575,7 +586,10 @@ async function maxDeposit(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('maxDeposit', e, { vault, receiver });
+        (0, core_1.logChainError)('maxDeposit', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            receiver,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `maxDeposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, receiver } });
     }
 }

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

@@ -297,7 +297,12 @@ async function approveCore(signer, options) {
     catch (e) {
         if (e instanceof core_1.AugustSDKError)
             throw e;
-        core_1.Logger.log.error('vaultApprove', e, { target, amount });
+        // 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), {
+            target,
+            amount,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `Approval failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, amount } });
     }
 }
@@ -632,7 +637,12 @@ async function vaultDeposit(signer, options) {
         }
         if (e instanceof core_1.AugustSDKError)
             throw e;
-        core_1.Logger.log.error('deposit', e, { target, amount, depositAsset });
+        // User-cancelled deposits are normal; only genuine failures stay at error.
+        (0, core_1.logChainError)('deposit', e, (0, core_1.isUserRejectionError)(e), {
+            target,
+            amount,
+            depositAsset,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `Deposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, amount, depositAsset } });
     }
 }
@@ -780,7 +790,11 @@ async function vaultRequestRedeem(signer, options) {
         }
         if (e instanceof core_1.AugustSDKError)
             throw e;
-        core_1.Logger.log.error('requestRedeem', e, { target, amount });
+        // User-cancelled redeem requests are normal; only genuine failures stay at error.
+        (0, core_1.logChainError)('requestRedeem', e, (0, core_1.isUserRejectionError)(e), {
+            target,
+            amount,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `Request redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, amount } });
     }
 }
@@ -823,7 +837,14 @@ async function vaultRedeem(signer, options) {
         }
         if (e instanceof core_1.AugustSDKError)
             throw e;
-        core_1.Logger.log.error('redeem', e, { target, year, month, day, receiverIndex });
+        // User-cancelled redeems are normal; only genuine failures stay at error.
+        (0, core_1.logChainError)('redeem', e, (0, core_1.isUserRejectionError)(e), {
+            target,
+            year,
+            month,
+            day,
+            receiverIndex,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `Redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, year, month, day, receiverIndex } });
     }
 }
@@ -914,7 +935,12 @@ async function depositNative(signer, options) {
         }
         if (e instanceof core_1.AugustSDKError)
             throw e;
-        core_1.Logger.log.error('depositNative', e, { wrapperAddress, receiver, amount });
+        // User-cancelled native deposits are normal; only genuine failures stay at error.
+        (0, core_1.logChainError)('depositNative', e, (0, core_1.isUserRejectionError)(e), {
+            wrapperAddress,
+            receiver,
+            amount,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `Deposit native failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { wrapperAddress, receiver, amount } });
     }
 }
@@ -988,7 +1014,13 @@ async function rwaRedeemAsset(signer, options) {
         }
         if (e instanceof core_1.AugustSDKError)
             throw e;
-        core_1.Logger.log.error('rwaRedeemAsset', e, { target, asset, amount, minOut });
+        // User-cancelled RWA redeems are normal; only genuine failures stay at error.
+        (0, core_1.logChainError)('rwaRedeemAsset', e, (0, core_1.isUserRejectionError)(e), {
+            target,
+            asset,
+            amount,
+            minOut,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `RWA redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, asset, amount, minOut } });
     }
 }

package/lib/sdk.d.ts

@@ -19011,7 +19011,7 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * only refresh user identity and the cached API-key hash.
             *
             * @param config - Analytics configuration. Pass `tracesSampleRate` to
-            *   override the Phase 1/2 default of `1.0`.
+            *   override the default of `0.1`.
             * @param environment - Current environment (DEV or PROD).
             * @param walletAddress - Optional wallet address for user identification.
             * @param apiKey - Optional API key (hashed for identification).
@@ -19405,6 +19405,34 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            export declare function isEarlierThanNow(startTime: Date): boolean;
 
+           /**
+            * Is this error a routine on-chain read revert rather than a real failure?
+            *
+            * Reading a function a contract doesn't implement, or an address that holds no
+            * (or incompatible) bytecode, reverts — a normal outcome when the SDK probes
+            * heterogeneous vaults. Matches ethers' `CALL_EXCEPTION` code and the
+            * message variants emitted by ethers and viem (`missing revert data`,
+            * `execution reverted`, `call revert exception`, and the bare `reverted`
+            * phrasing such as `the contract function "totalAssets" reverted`).
+            *
+            * Scope note: callers apply this on **read** paths only. A reverted *write*
+            * (a tx that failed on-chain) is a genuine error and is intentionally not
+            * demoted by this predicate's use in `write.actions`.
+            *
+            * @param error - The caught value, of unknown type.
+            * @returns `true` when the failure is an expected/benign contract revert.
+            *
+            * @example
+            * ```ts
+            * try { return await vaultContract.maxDepositAmount(); }
+            * catch (e) {
+            *   logChainError('maxDeposit', e, isExpectedRevertError(e));
+            *   throw e;
+            * }
+            * ```
+            */
+           export declare function isExpectedRevertError(error: unknown): boolean;
+
            /**
             * Whether a vault's receipt token is hub-only (no cross-chain withdraw).
             * The deposit UI must not offer a spoke share destination for these vaults.
@@ -19676,6 +19704,27 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                ownerAddr: IAddress;
            }
 
+           /**
+            * Is this error a wallet/user rejection of a transaction or signature request?
+            *
+            * Detects ethers v6's `ACTION_REJECTED` code, the EIP-1193 `4001`
+            * ("User rejected the request") code (top-level or nested), and the common
+            * human-readable phrasings as a fallback for providers that omit a code.
+            *
+            * @param error - The caught value, of unknown type.
+            * @returns `true` when the failure was the user declining in their wallet.
+            *
+            * @example
+            * ```ts
+            * try { await vault.deposit(...); }
+            * catch (e) {
+            *   if (isUserRejectionError(e)) return; // user cancelled — not an error
+            *   throw e;
+            * }
+            * ```
+            */
+           export declare function isUserRejectionError(error: unknown): boolean;
+
            /**
             * Signer Compatibility Helpers
             *
@@ -21072,6 +21121,26 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            export declare function loanStateToReadable(loanState: number | bigint): "PREAPPROVED" | "FUNDING_REQUIRED" | "FUNDED" | "ACTIVE" | "CANCELLED" | "MATURED" | "CLOSED";
 
+           /**
+            * 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`
+            * (a Sentry breadcrumb that rides along with the next real issue, not a billed
+            * standalone issue); otherwise it is logged at `error` (a Sentry issue). The
+            * caller is still responsible for re-throwing — this only routes telemetry.
+            *
+            * Pass the benign decision explicitly (via {@link isUserRejectionError} or
+            * {@link isExpectedRevertError}) so the call site documents *why* the demotion
+            * is safe and each path opts into only the category that applies to it.
+            *
+            * @param tag - Low-cardinality call-site label (e.g. `'deposit'`), used as the
+            *   Sentry breadcrumb/issue grouping key.
+            * @param error - The caught value, of unknown type.
+            * @param isBenign - `true` to demote to `warn`; `false` to keep at `error`.
+            * @param context - Optional structured context attached to the log entry. It is
+            *   sanitized by the logger before transport.
+            */
+           export declare function logChainError(tag: string, error: unknown, isBenign: boolean, context?: Record<string, unknown>): void;
+
            export declare const Logger: {
                setLogger: typeof setLogger;
                setStructuredLogger: typeof setStructuredLogger;

package/lib/services/subgraph/vaults.js

@@ -183,12 +183,19 @@ const NEW_DEPOSIT_QUERY_PROPS = `
     senderAddr
     receiverAddr
   `;
+// The `block_number: blockNumber` alias on these new-schema withdrawal prop
+// sets is required, not cosmetic: getWithdrawalRequestsWithStatus prunes by
+// `Number(req.block_number) >= blockCutoff` (per the ISubgraphBase contract).
+// New-schema subgraphs expose the field as `blockNumber`, so without the alias
+// it reads undefined → Number(undefined) is NaN → every request is pruned
+// (AUGUST-6514). Only the REQUESTED set is read today; the processed/withdrawals
+// aliases below are kept for the same type contract so the NaN prune can't recur.
 const NEW_WITHDRAWALS_REQUESTED_QUERY_PROPS = `
     id
     shares
     receiverAddr
     holderAddr
-    blockNumber
+    block_number: blockNumber
     transactionHash_: transactionHash
     timestamp_: blockTimestamp
 `;
@@ -196,7 +203,7 @@ const NEW_WITHDRAWALS_PROCESSED_QUERY_PROPS = `
     id
     receiverAddr
     assetsAmount
-    blockNumber
+    block_number: blockNumber
     transactionHash_: transactionHash
     timestamp_: blockTimestamp
 `;
@@ -204,7 +211,7 @@ const NEW_WITHDRAWALS_QUERY_PROPS = `
     id
     transactionHash_: transactionHash
     timestamp_: blockTimestamp
-    blockNumber
+    block_number: blockNumber
     assets
     receiver
     sender

package/package.json

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