@augustdigital/sdk 8.21.0 → 8.22.1

package/lib/core/analytics/sentry.js

@@ -384,12 +384,16 @@ function initializeSentry(config, environment, walletAddress, apiKey, appName) {
             ? config.tracesSampleRate
             : 0.1; // Phase 2 default — verified partners can opt into 1.0 explicitly
         const tracesSampleRate = Math.max(0, Math.min(1, rawSampleRate));
+        // Hoisted so `release`, `august.sdk_version`, and the deprecated
+        // `sdk.version` are provably the same value rather than three separate
+        // reads of `./version`.
+        const sdkVersion = getSDKVersion();
         sdk.init({
             dsn: constants_1.SENTRY_DSN,
             tracesSampleRate,
             enableTracing: true,
             environment: environment.toLowerCase(),
-            release: `august-sdk@${getSDKVersion()}`,
+            release: `august-sdk@${sdkVersion}`,
             sendDefaultPii: true,
             // SDK errors route through Logger.setSentrySink → captureException directly,
             // so captureConsoleIntegration is redundant here. Omitting it also prevents
@@ -445,7 +449,27 @@ function initializeSentry(config, environment, walletAddress, apiKey, appName) {
         updateUser(walletAddress, environment);
         // Set global SDK tags
         safeSetTag('sdk', 'august-digital');
-        safeSetTag('sdk.version', getSDKVersion());
+        // `august.sdk_version` is the queryable dimension for "which SDK build is
+        // this partner on" — the question that decides whether an error is a live
+        // defect or an already-shipped fix the consumer hasn't picked up.
+        //
+        // It exists because `sdk.version` (set below, kept for back-compat) is a
+        // RESERVED Sentry field: Sentry populates it with the version of its own
+        // client (`@sentry/core`). The custom tag is still stored, but a bare
+        // `sdk.version` in Discover resolves to Sentry's value, so the natural
+        // query silently answers the wrong question — uniform across every
+        // consumer, which makes it look like a working answer. Reaching the real
+        // value requires `tags[sdk.version]`, which nobody remembers to type.
+        //
+        // Both are low-cardinality version strings, so carrying the pair costs
+        // nothing against the tag budget (CLAUDE.md §8.4).
+        safeSetTag('august.sdk_version', sdkVersion);
+        /**
+         * @deprecated Shadowed by Sentry's reserved `sdk.version` field. Query
+         * `august.sdk_version` instead. Retained so existing saved queries,
+         * dashboards, and alert rules keep resolving; remove in the next major.
+         */
+        safeSetTag('sdk.version', sdkVersion);
         safeSetTag('sdk.runtime', (0, sentry_runtime_1.getSentryRuntime)());
         // `app.name` is the dimension we filter on in Sentry to attribute
         // events to a specific consuming application — see SDK quickstart docs.

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

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

@@ -69,7 +69,7 @@ export declare const NEMO_VAULT_ADDRESS = "0xa422c3018c46ba90a14acd14f96cb60616f
  * Subgraph base URL
  * @deprecated use getVaultMetadata to fetch subgraph URLs from the backend
  */
-export declare const GOLDSKY_BASE_URL = "https://api.goldsky.com/api/private/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs";
+export declare const GOLDSKY_BASE_URL = "https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs";
 /**
  * Subgraph URLs
  * @deprecated use getVaultMetadata to fetch subgraph URLs from the backend

package/lib/core/constants/vaults.js

@@ -131,7 +131,7 @@ exports.NEMO_VAULT_ADDRESS = '0xa422c3018c46ba90a14acd14f96cb60616f5c91b';
  * Subgraph base URL
  * @deprecated use getVaultMetadata to fetch subgraph URLs from the backend
  */
-exports.GOLDSKY_BASE_URL = 'https://api.goldsky.com/api/private/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs';
+exports.GOLDSKY_BASE_URL = 'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs';
 /**
  * Subgraph URLs
  * @deprecated use getVaultMetadata to fetch subgraph URLs from the backend

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

@@ -32,7 +32,8 @@ export declare const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEe
 /**
  * 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).
+ * Mezo, Monad, Plasma, Ink, Flare, Katana, Citrea, Fluent, Tempo, X Layer —
+ * whose native OKB is also 18 decimals).
  *
  * 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
@@ -73,7 +74,8 @@ export declare const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a17397
 /**
  * Chains where the canonical Multicall3 deployment was **verified on-chain**
  * (`eth_getCode` returned the 3808-byte runtime at {@link MULTICALL3_ADDRESS};
- * checked per chain on 2026-07-14, Tempo checked separately on 2026-07-15) —
+ * checked per chain on 2026-07-14, Tempo checked separately on 2026-07-15,
+ * X Layer on 2026-08-11) —
  * deterministic-deployer presence is NOT assumed. Chains outside this set
  * keep the per-call read path.
  *

package/lib/core/constants/web3.js

@@ -40,7 +40,8 @@ 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).
+ * Mezo, Monad, Plasma, Ink, Flare, Katana, Citrea, Fluent, Tempo, X Layer —
+ * whose native OKB is also 18 decimals).
  *
  * 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
@@ -160,6 +161,11 @@ exports.NETWORKS = {
         chainId: 4217,
         explorer: 'https://explore.tempo.xyz',
     },
+    196: {
+        name: 'X Layer',
+        chainId: 196,
+        explorer: 'https://xlayerscan.com',
+    },
 };
 exports.AVAILABLE_CHAINS = Object.keys(exports.NETWORKS).map((c) => Number(c));
 /**
@@ -171,7 +177,8 @@ exports.MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
 /**
  * Chains where the canonical Multicall3 deployment was **verified on-chain**
  * (`eth_getCode` returned the 3808-byte runtime at {@link MULTICALL3_ADDRESS};
- * checked per chain on 2026-07-14, Tempo checked separately on 2026-07-15) —
+ * checked per chain on 2026-07-14, Tempo checked separately on 2026-07-15,
+ * X Layer on 2026-08-11) —
  * deterministic-deployer presence is NOT assumed. Chains outside this set
  * keep the per-call read path.
  *
@@ -197,6 +204,7 @@ exports.MULTICALL3_VERIFIED_CHAINS = new Set([
     747474, // Katana
     25363, // Fluent
     4217, // Tempo
+    196, // X Layer
 ]);
 /**
  * Fallbacks
@@ -225,5 +233,6 @@ exports.FALLBACK_RPC_URLS = {
     4114: ['https://rpc.mainnet.citrea.xyz'],
     25363: ['https://rpc.fluent.xyz'],
     4217: ['https://rpc.mainnet.tempo.xyz'],
+    196: ['https://rpc.xlayer.tech'],
 };
 //# sourceMappingURL=web3.js.map

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

@@ -95,10 +95,16 @@ export { explorerLink } from './explorer-link';
  * Fetch token decimals from contract or Solana mint.
  * Results are cached to minimize RPC calls.
  *
- * **Never throws** — a failed read logs at error level and resolves
- * `undefined`. Callers that must not silently proceed on an unknown scale (any
- * path that encodes an amount) should use {@link getDecimalsOrThrow} instead:
- * feeding `undefined` into `toNormalizedBn` silently defaults to 18 decimals.
+ * **Never throws** — a failed read resolves `undefined`. Callers that must not
+ * silently proceed on an unknown scale (any path that encodes an amount) should
+ * use {@link getDecimalsOrThrow} instead: feeding `undefined` into
+ * `toNormalizedBn` silently defaults to 18 decimals.
+ *
+ * Transient transport faults (provider rate limits, socket resets, an empty
+ * response to `decimals()`) are logged at `warn` — a breadcrumb, not a
+ * standalone Sentry issue — since the caller sees the same `undefined` either
+ * way. Everything else is logged at `error`. The read itself is **not**
+ * retried here; that is opt-in via {@link getDecimalsOrThrow}.
  *
  * @param provider Web3 provider
  * @param address Token contract address or Solana mint

package/lib/core/helpers/web3.js

@@ -395,10 +395,16 @@ async function fetchDecimals(runner, address, isVault) {
  * Fetch token decimals from contract or Solana mint.
  * Results are cached to minimize RPC calls.
  *
- * **Never throws** — a failed read logs at error level and resolves
- * `undefined`. Callers that must not silently proceed on an unknown scale (any
- * path that encodes an amount) should use {@link getDecimalsOrThrow} instead:
- * feeding `undefined` into `toNormalizedBn` silently defaults to 18 decimals.
+ * **Never throws** — a failed read resolves `undefined`. Callers that must not
+ * silently proceed on an unknown scale (any path that encodes an amount) should
+ * use {@link getDecimalsOrThrow} instead: feeding `undefined` into
+ * `toNormalizedBn` silently defaults to 18 decimals.
+ *
+ * Transient transport faults (provider rate limits, socket resets, an empty
+ * response to `decimals()`) are logged at `warn` — a breadcrumb, not a
+ * standalone Sentry issue — since the caller sees the same `undefined` either
+ * way. Everything else is logged at `error`. The read itself is **not**
+ * retried here; that is opt-in via {@link getDecimalsOrThrow}.
  *
  * @param provider Web3 provider
  * @param address Token contract address or Solana mint
@@ -422,7 +428,27 @@ const getDecimals = async (provider, address, isVault = true) => {
         return await sharedDecimalsRequest(key, () => fetchDecimals(provider, address, isVault));
     }
     catch (e) {
-        logger_1.Logger.log.error('getDecimals', `${address}::${e}`);
+        // Severity split. A provider rate-limit or socket fault is not a defect in
+        // the SDK or the caller's input — the read resolves `undefined` either way,
+        // exactly as documented, and logging it at error level made a QuickNode
+        // `50/second request limit reached` burst the fourth highest-volume issue
+        // in Sentry with nothing actionable in it. Genuine failures (a non-ERC-20
+        // at this address, a real revert) stay at error.
+        //
+        // Note this only changes the log level. The no-retry contract of this
+        // lenient reader is deliberate and unchanged — callers that must not
+        // proceed on an unknown scale use `getDecimalsOrThrow`, which retries.
+        const isTransient = (0, chain_error_1.isRetryableRpcError)(e) || (0, chain_error_1.isEmptyViewResponse)(e, DECIMALS_SELECTOR);
+        if (isTransient) {
+            logger_1.Logger.log.warn('getDecimals', {
+                address,
+                reason: 'transient RPC failure',
+                message: e instanceof Error ? e.message : String(e),
+            });
+        }
+        else {
+            logger_1.Logger.log.error('getDecimals', `${address}::${e}`);
+        }
         return undefined;
     }
 };

package/lib/core/logger/slack.d.ts

@@ -1,7 +1,40 @@
 /**
- * The default Slack webhook URL for logging errors.
+ * Environment variable holding the Slack incoming-webhook to post SDK alerts
+ * to. Accepts either the full `https://hooks.slack.com/services/T…/B…/x…` URL
+ * or the bare `T…/B…/x…` path suffix.
  */
-export declare const DEFAULT_SLACK_WEBHOOK_URL = "T04CM84GAV6/B0A2DS3ST8C/FLtOA3Jna3FN7UO4DoGxHfhG";
+export declare const SLACK_WEBHOOK_ENV_VAR = "AUGUST_SDK_SLACK_WEBHOOK_URL";
+/**
+ * Resolve the Slack webhook to alert through.
+ *
+ * Why this replaced a hardcoded constant: a webhook path is a **bearer
+ * credential** — anyone holding it can post to the channel. The previous
+ * default embedded August's own webhook as a string literal, which shipped in
+ * every published tarball and in the generated `.d.ts`, handing every consumer
+ * of the SDK write access to an internal Slack channel (CLAUDE.md §5: no
+ * secrets in client-reachable code). It also meant a consumer's alerts went to
+ * August's channel rather than their own, with no way to redirect them.
+ *
+ * Resolution order:
+ *   1. `explicit` — passed by the caller, wins outright;
+ *   2. `AUGUST_SDK_SLACK_WEBHOOK_URL` in the environment;
+ *   3. none — alerting is disabled and the call becomes a no-op.
+ *
+ * Reading the env var per call (rather than once at module load) means a
+ * consumer configuring it after import still gets alerts, and a test can set
+ * and unset it without re-importing the module.
+ *
+ * @param explicit - Caller-supplied webhook, full URL or bare path suffix.
+ * @returns The bare `T…/B…/x…` path suffix, or `''` when unconfigured.
+ */
+export declare function resolveSlackWebhookUrl(explicit?: string): string;
+/**
+ * @deprecated Was a hardcoded webhook credential baked into the published
+ * bundle. It now resolves from {@link SLACK_WEBHOOK_ENV_VAR} and is `''` when
+ * unset. Call {@link resolveSlackWebhookUrl} instead — this export exists only
+ * so existing imports keep compiling, and is removed in the next major.
+ */
+export declare const DEFAULT_SLACK_WEBHOOK_URL = "";
 declare function error(options: {
     title: string;
     error: string;

package/lib/core/logger/slack.js

@@ -1,16 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SLACK = exports.DEFAULT_SLACK_WEBHOOK_URL = void 0;
+exports.SLACK = exports.DEFAULT_SLACK_WEBHOOK_URL = exports.SLACK_WEBHOOK_ENV_VAR = void 0;
+exports.resolveSlackWebhookUrl = resolveSlackWebhookUrl;
 const core_1 = require("../helpers/core");
 const explorer_link_1 = require("../helpers/explorer-link");
 const sanitize_1 = require("../analytics/sanitize");
+const env_1 = require("../analytics/env");
 /**
- * The default Slack webhook URL for logging errors.
+ * Environment variable holding the Slack incoming-webhook to post SDK alerts
+ * to. Accepts either the full `https://hooks.slack.com/services/T…/B…/x…` URL
+ * or the bare `T…/B…/x…` path suffix.
  */
-exports.DEFAULT_SLACK_WEBHOOK_URL = 'T04CM84GAV6/B0A2DS3ST8C/FLtOA3Jna3FN7UO4DoGxHfhG';
+exports.SLACK_WEBHOOK_ENV_VAR = 'AUGUST_SDK_SLACK_WEBHOOK_URL';
+/** `https://hooks.slack.com/services/` — stripped so both forms are accepted. */
+const SLACK_WEBHOOK_PREFIX = 'https://hooks.slack.com/services/';
+/**
+ * Resolve the Slack webhook to alert through.
+ *
+ * Why this replaced a hardcoded constant: a webhook path is a **bearer
+ * credential** — anyone holding it can post to the channel. The previous
+ * default embedded August's own webhook as a string literal, which shipped in
+ * every published tarball and in the generated `.d.ts`, handing every consumer
+ * of the SDK write access to an internal Slack channel (CLAUDE.md §5: no
+ * secrets in client-reachable code). It also meant a consumer's alerts went to
+ * August's channel rather than their own, with no way to redirect them.
+ *
+ * Resolution order:
+ *   1. `explicit` — passed by the caller, wins outright;
+ *   2. `AUGUST_SDK_SLACK_WEBHOOK_URL` in the environment;
+ *   3. none — alerting is disabled and the call becomes a no-op.
+ *
+ * Reading the env var per call (rather than once at module load) means a
+ * consumer configuring it after import still gets alerts, and a test can set
+ * and unset it without re-importing the module.
+ *
+ * @param explicit - Caller-supplied webhook, full URL or bare path suffix.
+ * @returns The bare `T…/B…/x…` path suffix, or `''` when unconfigured.
+ */
+function resolveSlackWebhookUrl(explicit) {
+    const raw = explicit?.trim() || (0, env_1.readEnv)(exports.SLACK_WEBHOOK_ENV_VAR)?.trim() || '';
+    return raw.startsWith(SLACK_WEBHOOK_PREFIX)
+        ? raw.slice(SLACK_WEBHOOK_PREFIX.length)
+        : raw;
+}
+/**
+ * @deprecated Was a hardcoded webhook credential baked into the published
+ * bundle. It now resolves from {@link SLACK_WEBHOOK_ENV_VAR} and is `''` when
+ * unset. Call {@link resolveSlackWebhookUrl} instead — this export exists only
+ * so existing imports keep compiling, and is removed in the next major.
+ */
+exports.DEFAULT_SLACK_WEBHOOK_URL = '';
+/** One-shot guard so an unconfigured webhook warns once, not per alert. */
+let warnedUnconfigured = false;
 function error(options) {
     const { title, error, poolAddress, chainId, slackWebookUrl, address } = options;
-    if (!slackWebookUrl) {
+    // Falls back to the environment so a caller that passes nothing still
+    // alerts, provided the deployment configured a webhook of its own.
+    const webhookPath = resolveSlackWebhookUrl(slackWebookUrl);
+    if (!webhookPath) {
+        // Silence here used to be the hardcoded-default's job. Say it once, so a
+        // deployment that expected alerts learns they are off instead of watching
+        // an empty channel. Never log the webhook value itself.
+        if (!warnedUnconfigured) {
+            warnedUnconfigured = true;
+            console.warn(`#Slack.error: no webhook configured — set ${exports.SLACK_WEBHOOK_ENV_VAR} to enable Slack alerts. Alerts are disabled.`);
+        }
         return;
     }
     if (!error) {
@@ -34,7 +88,7 @@ function error(options) {
         return;
     }
     (async () => {
-        const webhookUrl = `https://hooks.slack.com/services/${slackWebookUrl}`;
+        const webhookUrl = `${SLACK_WEBHOOK_PREFIX}${webhookPath}`;
         const safeError = (0, sanitize_1.sanitizeString)(String(error));
         const safeTitle = (0, sanitize_1.sanitizeString)(String(title));
         const data = {

package/lib/modules/vaults/getters.js

@@ -68,6 +68,7 @@ const abis_1 = require("../../abis");
 const types_1 = require("../../types");
 const core_1 = require("../../core");
 const ethers_1 = require("ethers");
+const cache_1 = require("../../core/cache");
 const utils_1 = require("./utils");
 const subgraph_1 = require("../../services/subgraph");
 const vaults_1 = require("../../services/subgraph/vaults");
@@ -356,8 +357,30 @@ async function getVaultSubaccountLoans(vault, options) {
  * HTTP statuses that mean "no such record for this subaccount", not "something
  * broke". The backend returns 404 for a subaccount with no CeFi/OTC position,
  * which is the normal case for most vault borrowers.
+ *
+ * `400` is here for the same reason. The CeFi and OTC endpoints answer `400`
+ * for a borrower they do not track — a well-formed, checksummed EVM address
+ * that simply has no record on that side — and every `getVaultAllocations`
+ * call re-asks for the same untracked borrowers on every render. In Sentry
+ * that produced ~2.7k `AugustServerError: Request failed: 400` events across
+ * two issues in two days, all from the same handful of borrowers, none of them
+ * actionable. Both fetches are strictly best-effort enrichment: the vault's
+ * allocations are returned either way, so a `400` here can never mean the
+ * caller's request was malformed.
+ *
+ * This demotes the *log severity* only — nothing about the response handling
+ * changes, and any other status (401, 5xx, transport failures) is still an
+ * error-level Sentry issue.
+ *
+ * **Maintainer note on the `400` entry specifically.** Unlike `204`/`404`, a
+ * `400` is semantically "the client sent something wrong", so this demotion is
+ * safe only for as long as these two endpoints use `400` to mean "unknown
+ * borrower". If either ever starts returning `400` for a genuinely malformed
+ * request — a real defect in how the SDK builds the URL or body — this set
+ * would silence it. Should that contract change, drop `400` from here and let
+ * the backend distinguish the two cases with a status of its own.
  */
-const EXPECTED_SUBACCOUNT_FETCH_STATUSES = new Set([204, 404]);
+const EXPECTED_SUBACCOUNT_FETCH_STATUSES = new Set([204, 400, 404]);
 /**
  * Log a per-subaccount enrichment fetch failure at the right severity.
  *
@@ -628,6 +651,87 @@ function subgraphAmountToBigInt(value) {
         return BigInt(0);
     }
 }
+/**
+ * Read `lagDuration()` off a vault, tolerating vaults that do not implement it.
+ *
+ * Why this exists: `getVaultAvailableRedemptions` binds every vault — v1 and
+ * v2 — to `ABI_LENDING_POOL_V2` because that ABI carries the superset of
+ * methods the scan needs. `lagDuration()` is not in that superset for every
+ * deployed pool. Calling it on a pool without the function reaches the
+ * fallback-less contract, which returns empty calldata, and ethers reports it
+ * as `missing revert data (action="call", data=null, …, code=CALL_EXCEPTION)`.
+ * That threw out of the whole redemption scan and became the single
+ * highest-volume error in production Sentry (~5.5k events over two days from
+ * three server deployments), while also returning an empty redemption list to
+ * every caller for the affected vaults.
+ *
+ * A missing `lagDuration()` means "this pool has no claim lag", which is what
+ * `0` encodes — the same value the v1 branch of the caller assumes.
+ *
+ * The empty response is **retried before it is believed**, because a provider
+ * that truncates an `eth_call` produces the identical shape: falling straight
+ * to `0` for a vault that really does have a lag would shift every computed
+ * claimable date. Only after the retries agree is the function treated as
+ * absent. A genuine revert carrying revert data still propagates, so real
+ * breakage stays loud.
+ *
+ * **The absence is memoized, the value is not.** Paying the retry budget (3
+ * `eth_call`s plus ~750ms of backoff) on every call for a vault that will never
+ * implement `lagDuration()` would trade an error flood for a latency and
+ * RPC-volume regression on exactly the vaults this path targets — a dashboard
+ * re-rendering redemptions pays it per render (CLAUDE.md §4.1, §4.2). Whether a
+ * deployed pool implements the function is fixed by its bytecode, so a
+ * confirmed absence is cacheable forever; the lag *value* is operator-settable
+ * and is deliberately never cached.
+ *
+ * Caveat on "fixed by its bytecode": an **upgradeable proxy** could gain a
+ * `lagDuration()` in a later implementation, and a process holding the memo
+ * would keep answering `0` for it. Bounded, not unbounded — `CACHE` carries a
+ * 24h TTL and `allowStale: true`, which serves an expired entry exactly once
+ * before evicting it, so the vault is re-read on the following call. Vaults
+ * behind an upgradeable proxy that add the function mid-process therefore
+ * misreport a zero lag for at most that window. Accepted deliberately: no
+ * deployed pool does this today, and the alternative is re-paying the retry
+ * budget forever for the vaults this path exists to serve.
+ *
+ * @param vaultContract - Anything exposing the vault's `lagDuration()` view;
+ *   structurally typed so both `ethers.Contract` and the ABI-typed contract
+ *   returned by `createContract` satisfy it.
+ * @param vault - Vault address, for the breadcrumb only.
+ * @param scope - Cache scope for the absence memo — the RPC endpoint the read
+ *   went through. Scoping by endpoint (rather than globally by address) keeps
+ *   the same address on two chains in separate entries.
+ * @returns The lag in seconds, or `0` when the vault has no `lagDuration()`.
+ * @throws The original error for any failure that is not an empty response.
+ */
+async function readLagDuration(vaultContract, vault, scope) {
+    const absenceKey = `lag-absent-${scope}-${vault.toLowerCase()}`;
+    // A vault proven not to implement the function cannot start implementing it.
+    if (cache_1.CACHE.get(absenceKey) === true)
+        return 0;
+    try {
+        return Number(await (0, core_1.retryOnTransientRpc)('getVaultAvailableRedemptions:lagDuration', () => vaultContract.lagDuration(), { vault }, (error) => (0, core_1.isRetryableRpcError)(error) ||
+            (0, core_1.isEmptyViewResponse)(error, LAG_DURATION_SELECTOR)));
+    }
+    catch (error) {
+        if (!(0, core_1.isEmptyViewResponse)(error, LAG_DURATION_SELECTOR))
+            throw error;
+        // Retries agreed the response is empty — record the absence so the next
+        // call short-circuits instead of re-paying the full retry budget.
+        cache_1.CACHE.set(absenceKey, true);
+        core_1.Logger.log.warn('getVaultAvailableRedemptions', {
+            vault,
+            reason: 'vault does not implement lagDuration(); assuming no claim lag',
+        });
+        return 0;
+    }
+}
+/**
+ * `lagDuration()` — `keccak256("lagDuration()")[0..4]`. Scopes the
+ * empty-response tolerance in {@link readLagDuration} to exactly that call, so
+ * an empty response to any *other* view still surfaces as an error.
+ */
+const LAG_DURATION_SELECTOR = '0x24e86d67';
 async function getVaultAvailableRedemptions({ vault, wallet, options, prefetchedReads, }) {
     try {
         // Stellar vaults don't support on-chain redemptions yet
@@ -674,7 +778,7 @@ async function getVaultAvailableRedemptions({ vault, wallet, options, prefetched
         }
         const lagDuration = typeof prefetchedReads?.lagDuration === 'number'
             ? prefetchedReads.lagDuration
-            : Number(await vaultContract.lagDuration());
+            : await readLagDuration(vaultContract, vault, options.rpcUrl);
         const { withdrawalRequesteds, withdrawalProcesseds } = await (0, subgraph_1.getSubgraphAllWithdrawals)(vault, provider);
         // format
         const availableRedemptions = [];
@@ -954,7 +1058,13 @@ async function getVaultRedemptionHistory({ vault, wallet, lookbackBlocks, option
         const currentBlock = await provider.getBlockNumber();
         const blockSkip = (0, core_1.determineBlockSkipInternal)(chainId);
         const cutoffBlock = currentBlock - (lookbackBlocks ?? (0, core_1.determineBlockCutoff)(chainId));
-        const BATCH_SIZE = 20; // Max concurrent RPC requests per batch
+        // Max concurrent `eth_getLogs` requests per batch. Kept well under the
+        // per-second cap of the smallest provider plan we run against (QuickNode:
+        // 50/s) because this scan is not the only caller on the connection — a
+        // page rendering several vaults runs several of these concurrently. At 20
+        // the batches reliably tripped `-32007 50/second request limit reached`,
+        // which the retry below now absorbs and this ceiling mostly avoids.
+        const BATCH_SIZE = 8;
         core_1.Logger.log.info('getVaultRedemptionHistory', {
             vault,
             version,
@@ -987,7 +1097,13 @@ async function getVaultRedemptionHistory({ vault, wallet, lookbackBlocks, option
         const logs = [];
         for (let i = 0; i < ranges.length; i += BATCH_SIZE) {
             const batch = ranges.slice(i, i + BATCH_SIZE);
-            const batchResults = await Promise.allSettled(batch.map((r) => poolContract.queryFilter('WithdrawalProcessed', BigInt(r.from), BigInt(r.to))));
+            const batchResults = await Promise.allSettled(batch.map((r) => 
+            // `eth_getLogs` over a fixed block range is idempotent, so a chunk
+            // rejected by a rate limiter or a flaky socket is safe to repeat.
+            // Without this a single `-32007` burst aborted the whole scan and
+            // the caller lost the redemption history entirely — the same failure
+            // mode the throw below was added to make visible.
+            (0, core_1.retryOnTransientRpc)('getVaultRedemptionHistory:chunk', () => poolContract.queryFilter('WithdrawalProcessed', BigInt(r.from), BigInt(r.to)), { vault, fromBlock: r.from, toBlock: r.to })));
             const failed = batchResults.filter((r) => r.status === 'rejected');
             if (failed.length > 0) {
                 const firstReason = failed[0].reason;

package/lib/sdk.d.ts

@@ -17419,9 +17419,12 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
           };
 
           /**
-           * The default Slack webhook URL for logging errors.
+           * @deprecated Was a hardcoded webhook credential baked into the published
+           * bundle. It now resolves from {@link SLACK_WEBHOOK_ENV_VAR} and is `''` when
+           * unset. Call {@link resolveSlackWebhookUrl} instead — this export exists only
+           * so existing imports keep compiling, and is removed in the next major.
            */
-          declare const DEFAULT_SLACK_WEBHOOK_URL = "T04CM84GAV6/B0A2DS3ST8C/FLtOA3Jna3FN7UO4DoGxHfhG";
+          declare const DEFAULT_SLACK_WEBHOOK_URL = "";
 
           /**
            * Deposit a native token (ETH / AVAX / etc.) into a vault via the
@@ -17568,7 +17571,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
             /**
              * 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).
+             * Mezo, Monad, Plasma, Ink, Flare, Katana, Citrea, Fluent, Tempo, X Layer —
+             * whose native OKB is also 18 decimals).
              *
              * 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
@@ -18322,10 +18326,16 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                       * Fetch token decimals from contract or Solana mint.
                       * Results are cached to minimize RPC calls.
                       *
-                      * **Never throws** — a failed read logs at error level and resolves
-                      * `undefined`. Callers that must not silently proceed on an unknown scale (any
-                      * path that encodes an amount) should use {@link getDecimalsOrThrow} instead:
-                      * feeding `undefined` into `toNormalizedBn` silently defaults to 18 decimals.
+                      * **Never throws** — a failed read resolves `undefined`. Callers that must not
+                      * silently proceed on an unknown scale (any path that encodes an amount) should
+                      * use {@link getDecimalsOrThrow} instead: feeding `undefined` into
+                      * `toNormalizedBn` silently defaults to 18 decimals.
+                      *
+                      * Transient transport faults (provider rate limits, socket resets, an empty
+                      * response to `decimals()`) are logged at `warn` — a breadcrumb, not a
+                      * standalone Sentry issue — since the caller sees the same `undefined` either
+                      * way. Everything else is logged at `error`. The read itself is **not**
+                      * retried here; that is opt-in via {@link getDecimalsOrThrow}.
                       *
                       * @param provider Web3 provider
                       * @param address Token contract address or Solana mint
@@ -19429,7 +19439,7 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                        * Subgraph base URL
                        * @deprecated use getVaultMetadata to fetch subgraph URLs from the backend
                        */
-                      export declare const GOLDSKY_BASE_URL = "https://api.goldsky.com/api/private/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs";
+                      export declare const GOLDSKY_BASE_URL = "https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs";
 
                       /**
                        * Deposit funds into a Solana August vault and mint share tokens.
@@ -24058,6 +24068,31 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                            */
                        export declare function resolveOriginCode(provided?: `0x${string}`): `0x${string}`;
 
+                       /**
+                        * Resolve the Slack webhook to alert through.
+                        *
+                        * Why this replaced a hardcoded constant: a webhook path is a **bearer
+                        * credential** — anyone holding it can post to the channel. The previous
+                        * default embedded August's own webhook as a string literal, which shipped in
+                        * every published tarball and in the generated `.d.ts`, handing every consumer
+                        * of the SDK write access to an internal Slack channel (CLAUDE.md §5: no
+                        * secrets in client-reachable code). It also meant a consumer's alerts went to
+                        * August's channel rather than their own, with no way to redirect them.
+                        *
+                        * Resolution order:
+                        *   1. `explicit` — passed by the caller, wins outright;
+                        *   2. `AUGUST_SDK_SLACK_WEBHOOK_URL` in the environment;
+                        *   3. none — alerting is disabled and the call becomes a no-op.
+                        *
+                        * Reading the env var per call (rather than once at module load) means a
+                        * consumer configuring it after import still gets alerts, and a test can set
+                        * and unset it without re-importing the module.
+                        *
+                        * @param explicit - Caller-supplied webhook, full URL or bare path suffix.
+                        * @returns The bare `T…/B…/x…` path suffix, or `''` when unconfigured.
+                        */
+                       declare function resolveSlackWebhookUrl(explicit?: string): string;
+
                        /* Excluded from this release type: resolveSpender */
 
                        /**
@@ -25088,12 +25123,21 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
 
                        declare namespace Slack {
                            export {
+                               resolveSlackWebhookUrl,
+                               SLACK_WEBHOOK_ENV_VAR,
                                DEFAULT_SLACK_WEBHOOK_URL,
                                SLACK
                            }
                        }
                        export { Slack }
 
+                       /**
+                        * Environment variable holding the Slack incoming-webhook to post SDK alerts
+                        * to. Accepts either the full `https://hooks.slack.com/services/T…/B…/x…` URL
+                        * or the bare `T…/B…/x…` path suffix.
+                        */
+                       declare const SLACK_WEBHOOK_ENV_VAR = "AUGUST_SDK_SLACK_WEBHOOK_URL";
+
                        export declare const Solana: {
                            utils: {
                                getExplorerLink: ({ signature, type, network, }: {

package/lib/services/subgraph/vaults.js

@@ -16,7 +16,7 @@ const fetcher_2 = require("../../modules/vaults/fetcher");
 /**
  * Utils
  */
-const GOLDSKY_API_KEY = 'cmd0lz6qf35lg01ty7u20aijy';
+const GOLDSKY_API_KEY = '';
 // Dedupe window for "Missing Subgraph" alerts (per pool).
 const MISSING_SUBGRAPH_ALERT_TTL_MS = 60 * 60 * 1000; // 1 hour
 /**
@@ -371,7 +371,7 @@ const TRANSFER_QUERY_PROPS = `
  * @param provider
  * @returns
  */
-async function getSubgraphWithdrawRequests(pool, provider, slackWebookUrl = slack_1.DEFAULT_SLACK_WEBHOOK_URL) {
+async function getSubgraphWithdrawRequests(pool, provider, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)()) {
     // setup
     let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
     if (vaultSymbol === undefined) {
@@ -443,7 +443,7 @@ async function getSubgraphWithdrawRequests(pool, provider, slackWebookUrl = slac
     requests.push(...(json?.data?.withdrawalRequesteds || []));
     return requests;
 }
-async function getSubgraphWithdrawProccessed(pool, provider, slackWebookUrl = slack_1.DEFAULT_SLACK_WEBHOOK_URL) {
+async function getSubgraphWithdrawProccessed(pool, provider, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)()) {
     try {
         // setup
         let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
@@ -526,7 +526,7 @@ async function getSubgraphWithdrawProccessed(pool, provider, slackWebookUrl = sl
  * @param provider
  * @returns
  */
-async function getSubgraphAllWithdrawals(pool, provider, slackWebookUrl = slack_1.DEFAULT_SLACK_WEBHOOK_URL) {
+async function getSubgraphAllWithdrawals(pool, provider, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)()) {
     let query = '';
     try {
         // setup
@@ -695,7 +695,7 @@ async function getArchivedVaultUserHistory(user, provider, pool) {
         // chronology. The backend returns rows in arbitrary order, so re-sort here.
         .sort((a, b) => Number(a.timestamp_) - Number(b.timestamp_)));
 }
-async function getSubgraphUserHistory(user, provider, pool, slackWebookUrl = slack_1.DEFAULT_SLACK_WEBHOOK_URL) {
+async function getSubgraphUserHistory(user, provider, pool, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)()) {
     try {
         // This path is EVM-only: it reads chain id and network from an EVM
         // JsonRpcProvider (eth_chainId / getNetwork) and queries an EVM subgraph.
@@ -847,7 +847,7 @@ async function getSubgraphUserHistory(user, provider, pool, slackWebookUrl = sla
         return [];
     }
 }
-async function getSubgraphVaultHistory(provider, pool, slackWebookUrl = slack_1.DEFAULT_SLACK_WEBHOOK_URL, opts = {}) {
+async function getSubgraphVaultHistory(provider, pool, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)(), opts = {}) {
     try {
         // setup
         const requests = [];
@@ -1008,7 +1008,7 @@ async function getSubgraphVaultHistory(provider, pool, slackWebookUrl = slack_1.
         return [];
     }
 }
-async function getSubgraphUserTransfers(user, provider, pool, slackWebookUrl = slack_1.DEFAULT_SLACK_WEBHOOK_URL) {
+async function getSubgraphUserTransfers(user, provider, pool, slackWebookUrl = (0, slack_1.resolveSlackWebhookUrl)()) {
     try {
         // setup
         let amountOfTransfers = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@augustdigital/sdk",
-  "version": "8.21.0",
+  "version": "8.22.1",
   "main": "lib/index.js",
   "types": "lib/sdk.d.ts",
   "keywords": [
@@ -66,6 +66,7 @@
     "test:jest:watch": "jest --config jest.config.unit.js --watch",
     "test:jest:coverage": "jest --config jest.config.unit.js --coverage",
     "test:forknet": "node tests/forknet/run.mjs",
+    "test:solana-localnet": "node tests/solana-localnet/run.mjs",
     "test:solana-idl": "jest --config jest.config.idl-drift.js",
     "clean": "rm -rf ./lib",
     "format": "biome check --write .",