@augustdigital/sdk 8.7.0 → 8.7.2

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

@@ -3,4 +3,4 @@
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-export declare const SDK_VERSION = "8.7.0";
+export declare const SDK_VERSION = "8.7.2";

package/lib/core/analytics/version.js

@@ -6,5 +6,5 @@ exports.SDK_VERSION = void 0;
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-exports.SDK_VERSION = '8.7.0';
+exports.SDK_VERSION = '8.7.2';
 //# sourceMappingURL=version.js.map

package/lib/core/constants/web3.js

@@ -117,6 +117,11 @@ exports.NETWORKS = {
         chainId: 25363,
         explorer: 'https://fluentscan.xyz',
     },
+    4217: {
+        name: 'Tempo',
+        chainId: 4217,
+        explorer: 'https://explore.tempo.xyz',
+    },
 };
 exports.AVAILABLE_CHAINS = Object.keys(exports.NETWORKS).map((c) => Number(c));
 /**
@@ -145,5 +150,6 @@ exports.FALLBACK_RPC_URLS = {
     747474: ['https://rpc.katana.network'],
     4114: ['https://rpc.mainnet.citrea.xyz'],
     25363: ['https://rpc.fluent.xyz'],
+    4217: ['https://rpc.mainnet.tempo.xyz'],
 };
 //# sourceMappingURL=web3.js.map

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

@@ -23,4 +23,26 @@ export declare const SUBGRAPH_POOL_URLS: (apiKey: string, chainId?: number, pool
 } | {
     999: string;
 };
-export declare const getDefaultSubgraphUrl: (network: string, symbol: string) => string;
+/**
+ * Previously fabricated a Goldsky subgraph URL from the chain name and vault
+ * symbol. That guess is unreliable and produced dead endpoints:
+ * - The path segment `/v1/subgraphs/name/goldsky/` is legacy hosted-service
+ *   syntax, not Goldsky's current scheme (cf. {@link SUBGRAPH_VAULT_URLS}).
+ * - The chain name isn't the subgraph slug — ethers reports Citrea's network as
+ *   `unknown`, and mainnet as `mainnet` where the subgraph uses `eth`.
+ * - A vault's symbol isn't its subgraph name — e.g. on-chain `EctUSD` vs the
+ *   deployed `earn-ctusd`.
+ *
+ * A fabricated URL 404s silently, so a missing subgraph reads as "no data"
+ * rather than an error (this masked the Citrea Earn ctUSD outage). Subgraph URLs
+ * must now come from backend vault metadata (`fetchVaultMetadata → subgraph`).
+ * This returns `undefined` so callers hit their existing "Missing Subgraph"
+ * branch (warn + Slack alert) instead of querying a dead endpoint.
+ *
+ * @param _network - Unused. Kept for call-site compatibility.
+ * @param _symbol - Unused. Kept for call-site compatibility.
+ * @returns `undefined` — the SDK no longer guesses subgraph URLs.
+ * @deprecated Resolve subgraph URLs from `fetchVaultMetadata`; do not rely on a
+ *   generated fallback.
+ */
+export declare const getDefaultSubgraphUrl: (_network: string, _symbol: string) => string | undefined;

package/lib/core/helpers/vaults.js

@@ -153,8 +153,30 @@ const SUBGRAPH_POOL_URLS = (apiKey, chainId, pool) => {
     return urls;
 };
 exports.SUBGRAPH_POOL_URLS = SUBGRAPH_POOL_URLS;
-const getDefaultSubgraphUrl = (network, symbol) => {
-    return `${vaults_1.GOLDSKY_BASE_URL}/v1/subgraphs/name/goldsky/august-${network.toLowerCase()}-${symbol}/1.0.0/gn`;
+/**
+ * Previously fabricated a Goldsky subgraph URL from the chain name and vault
+ * symbol. That guess is unreliable and produced dead endpoints:
+ * - The path segment `/v1/subgraphs/name/goldsky/` is legacy hosted-service
+ *   syntax, not Goldsky's current scheme (cf. {@link SUBGRAPH_VAULT_URLS}).
+ * - The chain name isn't the subgraph slug — ethers reports Citrea's network as
+ *   `unknown`, and mainnet as `mainnet` where the subgraph uses `eth`.
+ * - A vault's symbol isn't its subgraph name — e.g. on-chain `EctUSD` vs the
+ *   deployed `earn-ctusd`.
+ *
+ * A fabricated URL 404s silently, so a missing subgraph reads as "no data"
+ * rather than an error (this masked the Citrea Earn ctUSD outage). Subgraph URLs
+ * must now come from backend vault metadata (`fetchVaultMetadata → subgraph`).
+ * This returns `undefined` so callers hit their existing "Missing Subgraph"
+ * branch (warn + Slack alert) instead of querying a dead endpoint.
+ *
+ * @param _network - Unused. Kept for call-site compatibility.
+ * @param _symbol - Unused. Kept for call-site compatibility.
+ * @returns `undefined` — the SDK no longer guesses subgraph URLs.
+ * @deprecated Resolve subgraph URLs from `fetchVaultMetadata`; do not rely on a
+ *   generated fallback.
+ */
+const getDefaultSubgraphUrl = (_network, _symbol) => {
+    return undefined;
 };
 exports.getDefaultSubgraphUrl = getDefaultSubgraphUrl;
 //# sourceMappingURL=vaults.js.map

package/lib/modules/vaults/main.js

@@ -771,24 +771,34 @@ class AugustVaults extends core_1.AugustBase {
             }
             return formattedStandard;
         };
-        // If vault is provided, return history for that vault
+        // If vault is provided, return history for that vault. This path is
+        // EVM-only (see fetchVaultHistory → getSubgraphUserHistory); a non-EVM
+        // vault address would drive eth_chainId against a Solana/Stellar RPC.
         if (vault) {
-            finalArray = await fetchVaultHistory(vault, chainId);
+            finalArray = (0, ethers_1.isAddress)(vault)
+                ? await fetchVaultHistory(vault, chainId)
+                : [];
         }
         else {
             // Fetch all vaults
             const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, this.headers, false, false);
-            // If chainId is provided, return history for all vaults on that chain
+            // If chainId is provided, return history for all vaults on that chain.
+            // EVM-only: skip non-EVM (Solana/Stellar) vault addresses.
             if (chainId) {
-                const vaultsPerChain = allVaults.filter((v) => v.chain === chainId);
+                const vaultsPerChain = allVaults.filter((v) => v.chain === chainId && (0, ethers_1.isAddress)(v.address));
                 const vaultResponses = await Promise.all(vaultsPerChain.map((v) => fetchVaultHistory(v.address, v.chain)));
                 const flattened = vaultResponses.flat();
                 finalArray = flattened;
             }
             else {
-                // Else, fetch all history for all vaults across all initialized chains
-                // LayerZero vaults query subgraphs directly and don't need a provider
-                const vaultsPerAvailableProviders = allVaults.filter((v) => this.providers?.[v?.chain] || (0, deposits_1.isLayerZeroVault)(v.address));
+                // Else, fetch all history for all vaults across all initialized chains.
+                // Gate on isAddress(v.address): the Solana provider is registered under
+                // chainId -1, so without this a Solana vault passes `providers?.[v.chain]`
+                // and gets routed into the EVM subgraph path, throwing
+                // "eth_chainId is not available on SOLANA_MAINNET" on every fetch.
+                // LayerZero vaults query subgraphs directly and don't need a provider.
+                const vaultsPerAvailableProviders = allVaults.filter((v) => (0, ethers_1.isAddress)(v.address) &&
+                    (this.providers?.[v?.chain] || (0, deposits_1.isLayerZeroVault)(v.address)));
                 const vaultResponses = await Promise.all(vaultsPerAvailableProviders.map((v) => fetchVaultHistory(v.address, v.chain)));
                 const flattened = vaultResponses.flat();
                 finalArray = flattened;

package/lib/sdk.d.ts

@@ -17474,7 +17474,29 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             */
            export declare const getDecimals: (provider: IContractRunner, address: IAddress, isVault?: boolean) => Promise<number>;
 
-           export declare const getDefaultSubgraphUrl: (network: string, symbol: string) => string;
+           /**
+            * Previously fabricated a Goldsky subgraph URL from the chain name and vault
+            * symbol. That guess is unreliable and produced dead endpoints:
+            * - The path segment `/v1/subgraphs/name/goldsky/` is legacy hosted-service
+            *   syntax, not Goldsky's current scheme (cf. {@link SUBGRAPH_VAULT_URLS}).
+            * - The chain name isn't the subgraph slug — ethers reports Citrea's network as
+            *   `unknown`, and mainnet as `mainnet` where the subgraph uses `eth`.
+            * - A vault's symbol isn't its subgraph name — e.g. on-chain `EctUSD` vs the
+            *   deployed `earn-ctusd`.
+            *
+            * A fabricated URL 404s silently, so a missing subgraph reads as "no data"
+            * rather than an error (this masked the Citrea Earn ctUSD outage). Subgraph URLs
+            * must now come from backend vault metadata (`fetchVaultMetadata → subgraph`).
+            * This returns `undefined` so callers hit their existing "Missing Subgraph"
+            * branch (warn + Slack alert) instead of querying a dead endpoint.
+            *
+            * @param _network - Unused. Kept for call-site compatibility.
+            * @param _symbol - Unused. Kept for call-site compatibility.
+            * @returns `undefined` — the SDK no longer guesses subgraph URLs.
+            * @deprecated Resolve subgraph URLs from `fetchVaultMetadata`; do not rely on a
+            *   generated fallback.
+            */
+           export declare const getDefaultSubgraphUrl: (_network: string, _symbol: string) => string | undefined;
 
            /**
             * Fetches the total amount deposited by an address on a whitelist contract

package/lib/services/subgraph/schema.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Which field-naming schema a deployed August vault subgraph uses:
+ * - `'old'` — snake_case fields (`block_number`, `timestamp_`, `transactionHash_`).
+ * - `'new'` — camelCase fields (`blockNumber`, `blockTimestamp`, `transactionHash`).
+ *
+ * The two templates are otherwise equivalent; the SDK aliases new-schema fields
+ * back to the old internal names when querying, so the rest of the code only ever
+ * sees the old (snake_case) shape.
+ */
+export type SubgraphSchema = 'old' | 'new';
+/**
+ * True when a GraphQL error array reports an unknown field on the queried type
+ * (message contains "has no field") — the signature of a schema mismatch.
+ *
+ * @param errors - GraphQL `errors` array from a subgraph response (may be undefined).
+ * @returns `true` if any error message indicates an unknown field, else `false`.
+ */
+export declare function isSubgraphSchemaFieldError(errors: {
+    message?: string;
+}[] | undefined): boolean;
+/**
+ * Detects whether a deployed subgraph uses the old or new field schema by probing
+ * a single field (`blockTimestamp`) that exists only on the new template.
+ *
+ * This replaces the previous heuristic — "vault symbol present in the deprecated
+ * `SUBGRAPH_VAULT_URLS` map ⇒ old schema, else new" — which mis-guessed any
+ * newly-added vault whose subgraph shipped on the old template (e.g.
+ * `august-citrea-earn-ctusd`). A wrong guess made every subgraph read query
+ * non-existent field names, so the subgraph returned GraphQL errors with no
+ * `data` and the SDK silently returned empty sets — emptying the Pending
+ * Withdrawals and History tabs for that vault (AUGUST-6568).
+ *
+ * Because the schema is immutable for a fixed subgraph deployment, the result is
+ * cached per URL ({@link SCHEMA_TTL_MS}); across a page's positions/history/
+ * withdrawals reads this amounts to a single extra lightweight query per subgraph.
+ *
+ * Side effects: at most one HTTP POST to the subgraph per URL per TTL window.
+ *
+ * @param goldskyUrl - Fully-qualified subgraph GraphQL endpoint.
+ * @param apiKey - Optional Goldsky API key sent as a Bearer token.
+ * @returns `'old'` or `'new'`. Defaults to `'new'` when the URL is empty or the
+ *   probe is inconclusive (network error / unexpected response) — the schema the
+ *   majority of current vaults use.
+ */
+export declare function resolveSubgraphSchema(goldskyUrl: string, apiKey?: string): Promise<SubgraphSchema>;

package/lib/services/subgraph/schema.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSubgraphSchemaFieldError = isSubgraphSchemaFieldError;
+exports.resolveSubgraphSchema = resolveSubgraphSchema;
+const core_1 = require("../../core");
+const fetcher_1 = require("./fetcher");
+const SCHEMA_CACHE_PREFIX = 'subgraph-schema-';
+// A subgraph's schema is fixed for a given deployment/version, so one probe can
+// serve every subsequent read for a long time. Cache generously.
+const SCHEMA_TTL_MS = 60 * 60 * 1000; // 1 hour
+/**
+ * True when a GraphQL error array reports an unknown field on the queried type
+ * (message contains "has no field") — the signature of a schema mismatch.
+ *
+ * @param errors - GraphQL `errors` array from a subgraph response (may be undefined).
+ * @returns `true` if any error message indicates an unknown field, else `false`.
+ */
+function isSubgraphSchemaFieldError(errors) {
+    return Boolean(errors?.some((e) => e?.message?.includes('has no field')));
+}
+/**
+ * Detects whether a deployed subgraph uses the old or new field schema by probing
+ * a single field (`blockTimestamp`) that exists only on the new template.
+ *
+ * This replaces the previous heuristic — "vault symbol present in the deprecated
+ * `SUBGRAPH_VAULT_URLS` map ⇒ old schema, else new" — which mis-guessed any
+ * newly-added vault whose subgraph shipped on the old template (e.g.
+ * `august-citrea-earn-ctusd`). A wrong guess made every subgraph read query
+ * non-existent field names, so the subgraph returned GraphQL errors with no
+ * `data` and the SDK silently returned empty sets — emptying the Pending
+ * Withdrawals and History tabs for that vault (AUGUST-6568).
+ *
+ * Because the schema is immutable for a fixed subgraph deployment, the result is
+ * cached per URL ({@link SCHEMA_TTL_MS}); across a page's positions/history/
+ * withdrawals reads this amounts to a single extra lightweight query per subgraph.
+ *
+ * Side effects: at most one HTTP POST to the subgraph per URL per TTL window.
+ *
+ * @param goldskyUrl - Fully-qualified subgraph GraphQL endpoint.
+ * @param apiKey - Optional Goldsky API key sent as a Bearer token.
+ * @returns `'old'` or `'new'`. Defaults to `'new'` when the URL is empty or the
+ *   probe is inconclusive (network error / unexpected response) — the schema the
+ *   majority of current vaults use.
+ */
+async function resolveSubgraphSchema(goldskyUrl, apiKey) {
+    if (!goldskyUrl)
+        return 'new';
+    const key = `${SCHEMA_CACHE_PREFIX}${goldskyUrl}`;
+    const cached = core_1.CACHE.get(key);
+    if (cached)
+        return cached;
+    try {
+        // `blockTimestamp` is a new-schema-only field. If the subgraph rejects it
+        // with an unknown-field error, the deployment is old-schema. Schema
+        // validation is static, so this is authoritative even when the entity has
+        // zero rows.
+        const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, `{ withdrawalRequesteds(first: 1) { blockTimestamp } }`, apiKey);
+        let schema = 'new';
+        if (result.status === 200) {
+            const json = (await result.json());
+            if (isSubgraphSchemaFieldError(json?.errors)) {
+                schema = 'old';
+            }
+        }
+        core_1.CACHE.set(key, schema, { ttl: SCHEMA_TTL_MS });
+        return schema;
+    }
+    catch (e) {
+        // Don't cache an inconclusive probe — let the next call retry. Default to
+        // 'new' so freshly-deployed vaults keep working when the probe is flaky.
+        core_1.Logger.log.warn('resolveSubgraphSchema', `probe failed for ${goldskyUrl}, defaulting to new schema: ${e instanceof Error ? e.message : 'unknown error'}`);
+        return 'new';
+    }
+}
+//# sourceMappingURL=schema.js.map

package/lib/services/subgraph/vaults.js

@@ -7,14 +7,46 @@ exports.getSubgraphAllWithdrawals = getSubgraphAllWithdrawals;
 exports.getSubgraphUserHistory = getSubgraphUserHistory;
 exports.getSubgraphVaultHistory = getSubgraphVaultHistory;
 exports.getSubgraphUserTransfers = getSubgraphUserTransfers;
+const ethers_1 = require("ethers");
 const slack_1 = require("../../core/logger/slack");
 const fetcher_1 = require("./fetcher");
+const schema_1 = require("./schema");
 const core_1 = require("../../core");
 const fetcher_2 = require("../../modules/vaults/fetcher");
 /**
  * Utils
  */
 const GOLDSKY_API_KEY = 'cmd0lz6qf35lg01ty7u20aijy';
+// Dedupe window for "Missing Subgraph" alerts (per pool).
+const MISSING_SUBGRAPH_ALERT_TTL_MS = 60 * 60 * 1000; // 1 hour
+/**
+ * Emit a "Missing Subgraph" Slack alert at most once per pool per TTL.
+ *
+ * `getDefaultSubgraphUrl` now returns `undefined` for vaults with no metadata or
+ * hardcoded subgraph URL, which makes the readers' `if (!goldskyUrl)` branches
+ * reachable (previously the fabricated URL was always truthy, so they were dead
+ * code). Portfolio/history flows loop over every vault, so alerting on each read
+ * would flood the webhook for every metadata-less vault. Deduping per pool
+ * surfaces a genuinely-missing subgraph without the flood.
+ *
+ * @param args.source - Reader function name, for the alert body.
+ * @param args.pool - Vault address (used as the dedupe key, lowercased).
+ * @param args.chainId - Chain id for the alert context.
+ * @param args.slackWebookUrl - Optional override webhook URL.
+ */
+function alertMissingSubgraphOnce(args) {
+    const key = `missing-subgraph-alert-${args.pool.toLowerCase()}`;
+    if (core_1.CACHE.has(key))
+        return;
+    core_1.CACHE.set(key, true, { ttl: MISSING_SUBGRAPH_ALERT_TTL_MS });
+    slack_1.SLACK.error({
+        title: 'Missing Subgraph',
+        error: `#${args.source}: goldsky url is undefined`,
+        poolAddress: args.pool,
+        chainId: args.chainId,
+        slackWebookUrl: args.slackWebookUrl || '',
+    });
+}
 /**
  * earnAUSD exists on both Ethereum and Monad, so it needs a _monad suffix
  * to distinguish its Monad subgraph from the Ethereum one.
@@ -269,18 +301,21 @@ async function getSubgraphWithdrawRequests(pool, provider, slackWebookUrl = slac
     if (!goldskyUrl) {
         const chainId = await (0, core_1.getChainId)(provider);
         core_1.Logger.log.warn('getSubgraphWithdrawRequests', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
-        slack_1.SLACK.error({
-            title: 'Missing Subgraph',
-            error: '#getSubgraphWithdrawRequests: goldsky url is undefined',
-            poolAddress: pool,
-            chainId: chainId,
-            slackWebookUrl: slackWebookUrl || '',
+        alertMissingSubgraphOnce({
+            source: 'getSubgraphWithdrawRequests',
+            pool,
+            chainId,
+            slackWebookUrl,
         });
         return [];
     }
     const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool))?.[0];
     const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
-    const useOldSchema = isOldSubgraphSchema(vaultSymbol);
+    // Probe the deployed subgraph to learn its actual field schema (cached per
+    // URL) instead of guessing from the vault symbol. See resolveSubgraphSchema —
+    // the old symbol-map heuristic silently emptied this set for vaults deployed
+    // on the old template but absent from SUBGRAPH_VAULT_URLS (AUGUST-6568).
+    const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
     const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
     const withdrawalRequestedProps = useOldSchema
         ? version === 'evm-2'
@@ -331,18 +366,19 @@ async function getSubgraphWithdrawProccessed(pool, provider, slackWebookUrl = sl
         if (!goldskyUrl) {
             const chainId = await (0, core_1.getChainId)(provider);
             core_1.Logger.log.error('getSubgraphWithdrawProccessed.missing-subgraph-url', new Error('goldsky url is undefined'), { chainId, vaultSymbol, pool });
-            slack_1.SLACK.error({
-                title: 'Missing Subgraph',
-                error: '#getSubgraphWithdrawProccessed: goldsky url is undefined',
-                poolAddress: pool,
-                chainId: chainId,
-                slackWebookUrl: slackWebookUrl || '',
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphWithdrawProccessed',
+                pool,
+                chainId,
+                slackWebookUrl,
             });
             return [];
         }
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool))?.[0];
         const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
-        const useOldSchema = isOldSubgraphSchema(vaultSymbol);
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
         const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
         const withdrawalProcessedProps = useOldSchema
             ? version === 'evm-2'
@@ -408,18 +444,19 @@ async function getSubgraphAllWithdrawals(pool, provider, slackWebookUrl = slack_
         if (!goldskyUrl) {
             const chainId = await (0, core_1.getChainId)(provider);
             core_1.Logger.log.error('getSubgraphAllWithdrawals', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
-            slack_1.SLACK.error({
-                title: 'Missing Subgraph',
-                error: '#getSubgraphAllWithdrawals: goldsky url is undefined',
-                poolAddress: pool,
-                chainId: chainId,
-                slackWebookUrl: slackWebookUrl || '',
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphAllWithdrawals',
+                pool,
+                chainId,
+                slackWebookUrl,
             });
             return errorReturnObj;
         }
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool))?.[0];
         const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
-        const useOldSchema = isOldSubgraphSchema(vaultSymbol);
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
         const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
         const withdrawalRequestedProps = useOldSchema
             ? version === 'evm-2'
@@ -540,6 +577,15 @@ async function getArchivedVaultUserHistory(user, provider, pool) {
 }
 async function getSubgraphUserHistory(user, provider, pool, slackWebookUrl = slack_1.DEFAULT_SLACK_WEBHOOK_URL) {
     try {
+        // This path is EVM-only: it reads chain id and network from an EVM
+        // JsonRpcProvider (eth_chainId / getNetwork) and queries an EVM subgraph.
+        // A non-EVM (Solana / Stellar) vault address routed here would call
+        // eth_chainId against a Solana/Stellar RPC and fail with a 400
+        // ("eth_chainId is not available on SOLANA_MAINNET"). Bail early so non-EVM
+        // vaults are simply skipped rather than throwing on every history fetch.
+        if (!(0, ethers_1.isAddress)(pool)) {
+            return [];
+        }
         // Archived vaults: serve history from the backend Mongo snapshot instead of
         // the (retired) subgraph. The archived set is fetched from the backend (the
         // routing source of truth) so a vault is only rerouted once its history is
@@ -573,18 +619,19 @@ async function getSubgraphUserHistory(user, provider, pool, slackWebookUrl = sla
             (0, core_1.getDefaultSubgraphUrl)(networkValue.name, vaultSymbol);
         if (!goldskyUrl) {
             core_1.Logger.log.error('getSubgraphUserHistory', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
-            slack_1.SLACK.error({
-                title: 'Missing Subgraph',
-                error: '#getSubgraphUserHistory: goldsky url is undefined',
-                poolAddress: pool,
-                chainId: chainId,
-                slackWebookUrl: slackWebookUrl || '',
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphUserHistory',
+                pool,
+                chainId,
+                slackWebookUrl,
             });
             return requests;
         }
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool))?.[0];
         const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
-        const useOldSchema = isOldSubgraphSchema(vaultSymbol);
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
         const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
         const depositProps = useOldSchema
             ? version === 'evm-2'
@@ -695,18 +742,19 @@ async function getSubgraphVaultHistory(provider, pool, slackWebookUrl = slack_1.
         if (!goldskyUrl) {
             const chainId = await (0, core_1.getChainId)(provider);
             core_1.Logger.log.error('getSubgraphVaultHistory', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
-            slack_1.SLACK.error({
-                title: 'Missing Subgraph',
-                error: '#getSubgraphVaultHistory: goldsky url is undefined',
-                poolAddress: pool,
-                chainId: chainId,
-                slackWebookUrl: slackWebookUrl || '',
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphVaultHistory',
+                pool,
+                chainId,
+                slackWebookUrl,
             });
             return requests;
         }
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(pool))?.[0];
         const version = (0, core_1.getVaultVersionV2)(tokenizedVault);
-        const useOldSchema = isOldSubgraphSchema(vaultSymbol);
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
         const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
         const withdrawProps = useOldSchema
             ? version === 'evm-2'
@@ -850,16 +898,17 @@ async function getSubgraphUserTransfers(user, provider, pool, slackWebookUrl = s
         if (!goldskyUrl) {
             const chainId = await (0, core_1.getChainId)(provider);
             core_1.Logger.log.error('getSubgraphUserTransfers', `goldsky url is undefined: ${vaultSymbol}::${pool}`);
-            slack_1.SLACK.error({
-                title: 'Missing Subgraph',
-                error: '#getSubgraphUserTransfers: goldsky url is undefined',
-                poolAddress: pool,
-                chainId: chainId,
-                slackWebookUrl: slackWebookUrl || '',
+            alertMissingSubgraphOnce({
+                source: 'getSubgraphUserTransfers',
+                pool,
+                chainId,
+                slackWebookUrl,
             });
             return userTransfers;
         }
-        const useOldSchema = isOldSubgraphSchema(vaultSymbol);
+        // Probe the deployed subgraph's actual field schema (cached per URL) rather
+        // than guessing from the vault symbol — see resolveSubgraphSchema (AUGUST-6568).
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
         const orderByTimestamp = useOldSchema ? 'timestamp_' : 'blockTimestamp';
         const transferProps = useOldSchema
             ? TRANSFER_QUERY_PROPS

package/package.json

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