@upshiftfinance/sdk 0.0.0-stage → 0.1.0

package/lib/services/layerzero/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Shared LayerZero utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressToBytes32 = addressToBytes32;
+/**
+ * Convert Ethereum address to bytes32 format (left-padded with zeros)
+ * Used by LayerZero subgraph queries where addresses are stored in bytes32 format.
+ * @throws {Error} If address format is invalid
+ */
+function addressToBytes32(address) {
+    // Validate address format
+    if (!address.match(/^0x[a-fA-F0-9]{40}$/)) {
+        throw new Error(`Invalid Ethereum address format: ${address}. Expected format: 0x followed by 40 hexadecimal characters.`);
+    }
+    // Remove 0x prefix and convert to lowercase
+    const cleanAddress = address.replace(/^0x/i, '').toLowerCase();
+    // Pad with 24 zeros (12 bytes) to make it 32 bytes total
+    return '0x' + '0'.repeat(24) + cleanAddress;
+}
+//# sourceMappingURL=utils.js.map

package/lib/services/octavfi/fetcher.d.ts

@@ -0,0 +1,33 @@
+import type { IAddress, IWSMonitorHeaders } from '../../types';
+import type { IOctavfiPortfolio } from './types';
+/**
+ * Response of the Upshift API's vault-level Octav endpoint.
+ *
+ * Keys are the vault's Solana operator addresses (case-sensitive base58).
+ * Values are the operator's raw Octav portfolio, or an `{ error }` object when
+ * the backend holds no usable portfolio for that operator.
+ */
+export type IVaultOctavResponse = Record<string, IOctavfiPortfolio | {
+    error: string;
+}>;
+/**
+ * Fetch the Octav portfolios of every Solana operator of a vault in a single
+ * request to the Upshift public API.
+ *
+ * The API serves these from a cache that a backend cron refreshes, so this
+ * function never calls Octav and needs no Octav credentials. It makes exactly
+ * one HTTP request per call and never throws.
+ *
+ * @param vaultAddress - Vault address: EVM hex or Solana base58.
+ * @param headers - Optional monitoring headers forwarded with the request.
+ * @returns Dictionary of operator address to portfolio or error on a 200 or
+ *   207 (partial success) response; `false` on any other status or when the
+ *   request fails.
+ *
+ * @example
+ * ```ts
+ * const response = await fetchVaultOctavResponse(vaultAddress);
+ * const portfolio = response ? response[borrower] : undefined;
+ * ```
+ */
+export declare function fetchVaultOctavResponse(vaultAddress: IAddress, headers?: IWSMonitorHeaders): Promise<IVaultOctavResponse | false>;

package/lib/services/octavfi/fetcher.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVaultOctavResponse = fetchVaultOctavResponse;
+const core_1 = require("../../core");
+/**
+ * Fetch the Octav portfolios of every Solana operator of a vault in a single
+ * request to the Upshift public API.
+ *
+ * The API serves these from a cache that a backend cron refreshes, so this
+ * function never calls Octav and needs no Octav credentials. It makes exactly
+ * one HTTP request per call and never throws.
+ *
+ * @param vaultAddress - Vault address: EVM hex or Solana base58.
+ * @param headers - Optional monitoring headers forwarded with the request.
+ * @returns Dictionary of operator address to portfolio or error on a 200 or
+ *   207 (partial success) response; `false` on any other status or when the
+ *   request fails.
+ *
+ * @example
+ * ```ts
+ * const response = await fetchVaultOctavResponse(vaultAddress);
+ * const portfolio = response ? response[borrower] : undefined;
+ * ```
+ */
+async function fetchVaultOctavResponse(vaultAddress, headers) {
+    try {
+        const response = await (0, core_1.fetchUpshiftPublic)(core_1.WEBSERVER_ENDPOINTS.public.tokenizedVault.octav(vaultAddress), { headers: headers });
+        if (response.status === 200 || response.status === 207) {
+            return (await response.json());
+        }
+        core_1.Logger.log.error('fetchVaultOctavResponse', new Error(`HTTP ${response.status} ${response.statusText}`), { status: response.status, statusText: response.statusText });
+        return false;
+    }
+    catch (e) {
+        core_1.Logger.log.error('fetchVaultOctavResponse', e);
+        return false;
+    }
+}
+//# sourceMappingURL=fetcher.js.map

package/lib/services/octavfi/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fetcher';
+export * from './types';
+export * from './utils';

package/lib/services/octavfi/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fetcher"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=index.js.map

package/lib/services/octavfi/types.d.ts

@@ -0,0 +1,34 @@
+import type { IAddress } from '../../types';
+export type IOctavfiEndpoint = 'portfolio';
+export interface IOctavfiAsset {
+    balance: string;
+    symbol: string;
+    price: string;
+    value: string;
+    contractAddress?: IAddress;
+    chain: string;
+}
+export interface IOctavfiProtocolBreakdown {
+    key: string;
+    name: string;
+    value: string;
+    assets: IOctavfiAsset[];
+}
+export interface IOctavfiChainBreakdown {
+    key: string;
+    name: string;
+    value: string;
+    protocols: string[];
+}
+export interface IOctavfiPortfolio {
+    address: IAddress;
+    cashBalance: string;
+    dailyIncome: string;
+    dailyExpense: string;
+    fees: string;
+    feesFiat: string;
+    lastUpdated: string;
+    networth: string;
+    assetByProtocols: Record<string, IOctavfiProtocolBreakdown>;
+    chains: Record<string, IOctavfiChainBreakdown>;
+}

package/lib/services/octavfi/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/services/octavfi/utils.d.ts

@@ -0,0 +1,16 @@
+import type { IOctavfiPortfolio } from './types';
+import type { IDebankNormalizedResponse } from '../debank/utils';
+/**
+ * Transforms Octavfi portfolio response to DeBank-compatible format.
+ * This allows Solana addresses to use Octavfi data while maintaining
+ * compatibility with existing DeBank parsing functions.
+ *
+ * @param octavfiPortfolio - Octavfi portfolio response
+ * @returns DeBank-compatible response structure
+ */
+export declare function transformOctavfiToDebank(octavfiPortfolio: IOctavfiPortfolio | null | undefined): IDebankNormalizedResponse;
+/**
+ * Transforms multiple Octavfi portfolios to DeBank format.
+ * Used when fetching multiple addresses.
+ */
+export declare function transformOctavfiPortfoliosToDebank(portfolios: IOctavfiPortfolio[]): IDebankNormalizedResponse[];

package/lib/services/octavfi/utils.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOctavfiToDebank = transformOctavfiToDebank;
+exports.transformOctavfiPortfoliosToDebank = transformOctavfiPortfoliosToDebank;
+/**
+ * Transforms Octavfi portfolio response to DeBank-compatible format.
+ * This allows Solana addresses to use Octavfi data while maintaining
+ * compatibility with existing DeBank parsing functions.
+ *
+ * @param octavfiPortfolio - Octavfi portfolio response
+ * @returns DeBank-compatible response structure
+ */
+function transformOctavfiToDebank(octavfiPortfolio) {
+    if (!octavfiPortfolio) {
+        return {
+            subaccount: {
+                positions: [],
+                tokens: [],
+            },
+        };
+    }
+    const positions = [];
+    const tokens = [];
+    // Transform protocols (assetByProtocols) into DeBank positions format
+    const assetByProtocols = octavfiPortfolio.assetByProtocols || {};
+    Object.entries(assetByProtocols).forEach(([protocolKey, protocol]) => {
+        // Skip wallet protocol - we'll handle it separately in tokens
+        if (protocolKey === 'wallet') {
+            return;
+        }
+        const { supplyAssets, borrowAssets } = collectProtocolLegs(protocol);
+        // Octav's protocol value is already net of debt, so it stays the net and
+        // the borrow legs are added back to give the gross supplied value.
+        const netUsdValue = parseFloat(protocol.value || '0') || 0;
+        const debtUsdValue = borrowAssets.reduce((sum, asset) => sum + assetUsdValue(asset), 0);
+        // Create position structure matching DeBank format
+        const position = {
+            id: protocolKey,
+            chain: getChainFromProtocol(protocol, octavfiPortfolio),
+            name: protocol.name || protocolKey,
+            logo_url: '', // Octavfi doesn't provide protocol logos
+            site_url: '', // Octavfi doesn't provide protocol URLs
+            portfolio_item_list: [
+                {
+                    name: protocol.name || protocolKey,
+                    stats: {
+                        asset_usd_value: netUsdValue + debtUsdValue,
+                        debt_usd_value: debtUsdValue,
+                        net_usd_value: netUsdValue,
+                    },
+                    detail: {
+                        supply_token_list: supplyAssets
+                            .map((asset) => transformAssetToDebankToken(asset, 'supply'))
+                            .filter((token) => token !== null),
+                        borrow_token_list: borrowAssets
+                            .map((asset) => transformAssetToDebankToken(asset, 'borrow'))
+                            .filter((token) => token !== null),
+                    },
+                },
+            ],
+        };
+        positions.push(position);
+    });
+    // Transform wallet assets to tokens array
+    const walletProtocol = assetByProtocols['wallet'];
+    if (walletProtocol && walletProtocol.chains) {
+        // Extract assets from nested structure: chains -> protocolPositions -> assets
+        Object.values(walletProtocol.chains).forEach((chain) => {
+            if (chain.protocolPositions) {
+                Object.values(chain.protocolPositions).forEach((protocolPosition) => {
+                    if (protocolPosition.assets &&
+                        Array.isArray(protocolPosition.assets)) {
+                        protocolPosition.assets.forEach((asset) => {
+                            tokens.push({
+                                ...transformAssetToDebankToken(asset, 'wallet'),
+                                is_wallet: true,
+                                is_core: true, // Assume wallet tokens are core tokens
+                            });
+                        });
+                    }
+                });
+            }
+        });
+    }
+    // Also add protocol assets as tokens (non-wallet). Deliberately walks only
+    // `assets`, not the lending `supplyAssets`/`borrowAssets` legs that
+    // `collectProtocolLegs` puts on the positions above: downstream parsers
+    // count `tokens` as wallet holdings, so adding the legs here would count
+    // collateral twice and report debt as a positive holding.
+    Object.entries(assetByProtocols).forEach(([protocolKey, protocol]) => {
+        if (protocolKey === 'wallet')
+            return;
+        if (!protocol || !protocol.chains)
+            return;
+        // Extract assets from nested structure
+        Object.values(protocol.chains).forEach((chain) => {
+            if (chain.protocolPositions) {
+                Object.values(chain.protocolPositions).forEach((protocolPosition) => {
+                    // Direct assets
+                    if (protocolPosition.assets &&
+                        Array.isArray(protocolPosition.assets)) {
+                        protocolPosition.assets.forEach((asset) => {
+                            // Check if token already exists (from wallet)
+                            const existingToken = tokens.find((t) => t.symbol === asset.symbol &&
+                                t.chain === (asset.chainKey || asset.chain));
+                            if (!existingToken) {
+                                tokens.push({
+                                    ...transformAssetToDebankToken(asset, 'supply'),
+                                    is_wallet: false,
+                                    is_core: true, // Assume protocol tokens are core
+                                });
+                            }
+                        });
+                    }
+                    // Nested protocolPositions (like in Kamino)
+                    if (protocolPosition.protocolPositions &&
+                        Array.isArray(protocolPosition.protocolPositions)) {
+                        protocolPosition.protocolPositions.forEach((nestedPos) => {
+                            if (nestedPos.assets && Array.isArray(nestedPos.assets)) {
+                                nestedPos.assets.forEach((asset) => {
+                                    const existingToken = tokens.find((t) => t.symbol === asset.symbol &&
+                                        t.chain === (asset.chainKey || asset.chain));
+                                    if (!existingToken) {
+                                        tokens.push({
+                                            ...transformAssetToDebankToken(asset, 'supply'),
+                                            is_wallet: false,
+                                            is_core: true,
+                                        });
+                                    }
+                                });
+                            }
+                        });
+                    }
+                });
+            }
+        });
+    });
+    return {
+        subaccount: {
+            positions,
+            tokens,
+        },
+    };
+}
+/**
+ * Collects a protocol's supply and borrow legs across its chains and position
+ * groups.
+ *
+ * Octav nests positions as `chains -> protocolPositions -> group`, where a
+ * group holds plain `assets` (vault shares) or a list of positions. A lending
+ * position (a Kamino obligation) keeps its collateral in `supplyAssets` and its
+ * debt in `borrowAssets` rather than in `assets`; reading only `assets` gave a
+ * lending position its net value with no collateral or debt behind it.
+ *
+ * @param protocol - One entry of a portfolio's `assetByProtocols`
+ * @returns The supply legs (plain and collateral assets) and the borrow legs
+ */
+function collectProtocolLegs(protocol) {
+    const supplyAssets = [];
+    const borrowAssets = [];
+    const collect = (position) => {
+        for (const key of ['assets', 'supplyAssets']) {
+            if (Array.isArray(position?.[key]))
+                supplyAssets.push(...position[key]);
+        }
+        if (Array.isArray(position?.borrowAssets)) {
+            borrowAssets.push(...position.borrowAssets);
+        }
+    };
+    Object.values(protocol?.chains ?? {}).forEach((chain) => {
+        Object.values(chain?.protocolPositions ?? {}).forEach((group) => {
+            collect(group);
+            // Nested protocolPositions (like in Kamino)
+            if (Array.isArray(group?.protocolPositions)) {
+                group.protocolPositions.forEach(collect);
+            }
+        });
+    });
+    return { supplyAssets, borrowAssets };
+}
+/**
+ * An Octav asset's USD value: its `value` when present, else balance × price.
+ */
+function assetUsdValue(asset) {
+    const value = parseFloat(asset?.value);
+    if (Number.isFinite(value))
+        return value;
+    return (parseFloat(asset?.balance) || 0) * (parseFloat(asset?.price) || 0);
+}
+/**
+ * Transforms Octavfi asset to DeBank token format
+ */
+function transformAssetToDebankToken(asset, // Using any since the actual structure differs from IOctavfiAsset
+exposureType) {
+    if (!asset) {
+        return null;
+    }
+    const balance = parseFloat(asset.balance || '0') || 0;
+    const price = parseFloat(asset.price || '0') || 0;
+    const amount = balance;
+    const chain = asset.chainKey || asset.chain || 'unknown';
+    const contract = asset.contract || asset.chainContract || asset.contractAddress;
+    const decimals = parseInt(asset.decimal || asset.decimals || '18', 10);
+    return {
+        id: contract || asset.symbol || 'unknown', // Use contract address if available, fallback to symbol
+        chain: chain,
+        name: asset.name || asset.symbol || 'Unknown',
+        symbol: asset.symbol || 'UNKNOWN',
+        optimized_symbol: asset.symbol || 'UNKNOWN',
+        decimals: decimals,
+        logo_url: '', // Octavfi doesn't provide token logos
+        amount,
+        price,
+        protocol_id: '', // Will be set by the calling context
+        supplying_exposure: exposureType === 'supply' ? 'true' : undefined,
+    };
+}
+/**
+ * Determines the chain from protocol data or portfolio chains
+ */
+function getChainFromProtocol(protocol, portfolio) {
+    // Try to get chain from protocol.chains structure
+    if (protocol.chains) {
+        const chainKeys = Object.keys(protocol.chains);
+        if (chainKeys.length > 0) {
+            return chainKeys[0];
+        }
+    }
+    // Fallback to first chain in portfolio
+    const chains = portfolio.chains || {};
+    const chainKeys = Object.keys(chains);
+    if (chainKeys.length > 0) {
+        return chainKeys[0];
+    }
+    return 'unknown';
+}
+/**
+ * Transforms multiple Octavfi portfolios to DeBank format.
+ * Used when fetching multiple addresses.
+ */
+function transformOctavfiPortfoliosToDebank(portfolios) {
+    return portfolios.map(transformOctavfiToDebank);
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,2 @@
+export declare function fetchSubgraph(graphUrl: string, query: string, apiKey?: string): Promise<Response>;
+export declare function fetchSubgraphWithRetry(graphUrl: string, query: string, apiKey?: string, maxRetries?: number, baseDelay?: number): Promise<Response>;

package/lib/services/subgraph/fetcher.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSubgraph = fetchSubgraph;
+exports.fetchSubgraphWithRetry = fetchSubgraphWithRetry;
+const core_1 = require("../../core");
+async function fetchSubgraph(graphUrl, query, apiKey) {
+    return fetchSubgraphWithRetry(graphUrl, query, apiKey);
+}
+async function fetchSubgraphWithRetry(graphUrl, query, apiKey, maxRetries = 3, baseDelay = 1000) {
+    if (!graphUrl) {
+        throw new Error('#fetchSubgraph: URL is not defined');
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            // Abort a hung subgraph request after the SDK-wide REQUEST_TIMEOUT_MS
+            // (15 s). The retry loop below re-arms a fresh timer per attempt.
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), core_1.REQUEST_TIMEOUT_MS);
+            try {
+                const headers = {
+                    'Content-Type': 'application/json',
+                };
+                if (apiKey) {
+                    headers['Authorization'] = `Bearer ${apiKey}`;
+                }
+                const response = await fetch(graphUrl, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
+                        query: `query ${query}`,
+                    }),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                return response;
+            }
+            catch (fetchError) {
+                clearTimeout(timeoutId);
+                throw fetchError;
+            }
+        }
+        catch (error) {
+            lastError = error;
+            // Retry only transient failures (network drop, abort/timeout) while we
+            // have retries left. `fetch` can reject with non-Error values (e.g. a
+            // string from a polyfill), so narrow before touching `.message`.
+            const isRetryable = error instanceof Error &&
+                ((error instanceof TypeError &&
+                    error.message.includes('fetch failed')) ||
+                    error.name === 'AbortError' ||
+                    error.message.includes('ETIMEDOUT') ||
+                    error.message.includes('timeout'));
+            if (attempt < maxRetries && isRetryable) {
+                const delay = baseDelay * 2 ** attempt; // Exponential backoff
+                core_1.Logger.log.warn(`fetchSubgraph`, `${graphUrl?.includes('/subgraphs') ? graphUrl?.split('/subgraphs/')?.[1]?.split('/')?.[0] : graphUrl}: Attempt ${attempt + 1} failed, retrying in ${delay}ms`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                continue;
+            }
+            // If it's not a retryable error or we're out of retries, throw
+            throw error;
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=fetcher.js.map

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

@@ -0,0 +1,2 @@
+export * from './vaults';
+export * from './fetcher';

package/lib/services/subgraph/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./vaults"), exports);
+__exportStar(require("./fetcher"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,48 @@
+/**
+ * Which field-naming schema a deployed Upshift 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, on
+ * `withdrawalRequesteds`, or on `transfers` for a receipt-token subgraph that
+ * has no `withdrawalRequesteds` entity.
+ *
+ * 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.
+ *
+ * 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 two HTTP POSTs to the subgraph per URL per TTL window
+ * (the second only for a subgraph without `withdrawalRequesteds`).
+ *
+ * @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,87 @@
+"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')));
+}
+// GraphQL errors from querying `blockTimestamp` on one row of `entity`;
+// undefined on a non-200 response or a clean result.
+async function probeSchemaErrors(goldskyUrl, entity, apiKey) {
+    const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, `{ ${entity}(first: 1) { blockTimestamp } }`, apiKey);
+    if (result.status !== 200)
+        return undefined;
+    const json = (await result.json());
+    return json?.errors;
+}
+/**
+ * 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, on
+ * `withdrawalRequesteds`, or on `transfers` for a receipt-token subgraph that
+ * has no `withdrawalRequesteds` entity.
+ *
+ * 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.
+ *
+ * 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 two HTTP POSTs to the subgraph per URL per TTL window
+ * (the second only for a subgraph without `withdrawalRequesteds`).
+ *
+ * @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. A receipt-token subgraph indexes only `transfers`, so when
+        // `withdrawalRequesteds` itself is unknown the probe moves to `transfers`.
+        let errors = await probeSchemaErrors(goldskyUrl, 'withdrawalRequesteds', apiKey);
+        if (errors?.some((e) => e?.message?.includes('has no field `withdrawalRequesteds`'))) {
+            errors = await probeSchemaErrors(goldskyUrl, 'transfers', apiKey);
+        }
+        const schema = isSubgraphSchemaFieldError(errors)
+            ? 'old'
+            : 'new';
+        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