@steerprotocol/sdk 3.5.0 → 3.6.0

package/dist/index.browser.mjs

@@ -16376,6 +16376,47 @@ const FIND_ALL_VAULTS_BY_PROTOCOL = (batchSize = 1e3, timestamp, beaconNames) =>
     }
   }`;
 };
+const FIND_VAULT_BY_ADDRESS = (vaultAddress) => `query {
+  vaults(first: 1, where: { id: "${vaultAddress}" }) {
+    id
+    name
+    token0
+    token1
+    pool
+    weeklyFeeAPR
+    token0Symbol
+    token0Decimals
+    token1Symbol
+    token1Decimals
+    totalValueLockedToken0
+    totalValueLockedToken1
+    token0Balance
+    token1Balance
+    totalLPTokensIssued
+    createdAt
+    feeTier
+    strategyToken {
+      id
+      name
+      creator {
+        id
+      }
+      admin
+      executionBundle
+    }
+    positions(first: 1, orderBy: timestamp, orderDirection: desc) {
+      id
+      upperTick
+      lowerTick
+      relativeWeight
+    }
+    fees0
+    fees1
+    beaconName
+    payloadIpfs
+    deployer
+  }
+}`;
 /**
 * Utility class for fetching vault data from Steer subgraphs
 */
@@ -16506,6 +16547,29 @@ var SubgraphVaultClient = class {
 		};
 	}
 	/**
+	* Fetches one vault by its address without enumerating the chain's vault set.
+	*/
+	async getVaultByAddress(options) {
+		const { subgraphUrl, chainId, vaultAddress } = options;
+		if (!vaultAddress) throw new Error("vaultAddress is required for an address lookup");
+		const vault = (await (await fetch(subgraphUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...subgraphUrl.includes("sentio") && this.SENTIO_API_KEY ? { "api-key": this.SENTIO_API_KEY } : {}
+			},
+			body: JSON.stringify({
+				query: FIND_VAULT_BY_ADDRESS(vaultAddress.toLowerCase()),
+				variables: {}
+			})
+		})).json())?.data?.vaults?.[0];
+		if (!vault) return null;
+		return this.transformSubgraphVaultToVaultNode({
+			...vault,
+			lpPriceData: this.createMockLpPriceData(vault)
+		}, chainId, /* @__PURE__ */ new Map());
+	}
+	/**
 	* Fetch vault data from subgraph
 	*/
 	async getAllVaultsFromSubgraph(options) {
@@ -20489,6 +20553,45 @@ var VaultClient = class extends SubgraphClient {
 		}
 		return apiFilter;
 	}
+	transformApiVaultNode(vault) {
+		return {
+			id: vault.id,
+			chainId: vault.chainId,
+			vaultAddress: vault.vaultAddress,
+			protocol: vault.protocol,
+			beaconName: vault.beaconName,
+			protocolBaseType: vault.protocolBaseType,
+			name: vault.name || "",
+			feeApr: vault.feeApr || void 0,
+			stakingApr: vault.stakingApr || void 0,
+			merklApr: vault.merklApr || void 0,
+			pool: {
+				id: vault.pool?.id || "",
+				poolAddress: vault.pool?.poolAddress || "",
+				feeTier: vault.pool?.feeTier || "",
+				tick: void 0,
+				liquidity: void 0,
+				volumeUSD: void 0,
+				totalValueLockedUSD: void 0
+			},
+			token0: {
+				id: vault.token0?.id || "",
+				symbol: vault.token0?.symbol || "",
+				name: vault.token0?.name || "",
+				decimals: vault.token0?.decimals || 0,
+				address: vault.token0?.address || "",
+				chainId: vault.token0?.chainId || 0
+			},
+			token1: {
+				id: vault.token1?.id || "",
+				symbol: vault.token1?.symbol || "",
+				name: vault.token1?.name || "",
+				decimals: vault.token1?.decimals || 0,
+				address: vault.token1?.address || "",
+				chainId: vault.token1?.chainId || 0
+			}
+		};
+	}
 	vaultMatchesProtocolFilter(vault, protocolFilter, resolvedProtocol) {
 		const normalizedFilter = this.normalizeProtocolValue(protocolFilter);
 		const normalizedBeaconName = this.normalizeProtocolValue(vault.beaconName);
@@ -20672,43 +20775,7 @@ var VaultClient = class extends SubgraphClient {
 				data: {
 					edges: response.data.vaults.edges.map((edge) => ({
 						cursor: edge.cursor,
-						node: {
-							id: edge.node.id,
-							chainId: edge.node.chainId,
-							vaultAddress: edge.node.vaultAddress,
-							protocol: edge.node.protocol,
-							beaconName: edge.node.beaconName,
-							protocolBaseType: edge.node.protocolBaseType,
-							name: edge.node.name || "",
-							feeApr: edge.node.feeApr || void 0,
-							stakingApr: edge.node.stakingApr || void 0,
-							merklApr: edge.node.merklApr || void 0,
-							pool: {
-								id: edge.node.pool?.id || "",
-								poolAddress: edge.node.pool?.poolAddress || "",
-								feeTier: edge.node.pool?.feeTier || "",
-								tick: void 0,
-								liquidity: void 0,
-								volumeUSD: void 0,
-								totalValueLockedUSD: void 0
-							},
-							token0: {
-								id: edge.node.token0?.id || "",
-								symbol: edge.node.token0?.symbol || "",
-								name: edge.node.token0?.name || "",
-								decimals: edge.node.token0?.decimals || 0,
-								address: edge.node.token0?.address || "",
-								chainId: edge.node.token0?.chainId || 0
-							},
-							token1: {
-								id: edge.node.token1?.id || "",
-								symbol: edge.node.token1?.symbol || "",
-								name: edge.node.token1?.name || "",
-								decimals: edge.node.token1?.decimals || 0,
-								address: edge.node.token1?.address || "",
-								chainId: edge.node.token1?.chainId || 0
-							}
-						}
+						node: this.transformApiVaultNode(edge.node)
 					})),
 					pageInfo: {
 						hasNextPage: response.data.vaults.pageInfo.hasNextPage,
@@ -21245,21 +21312,62 @@ var VaultClient = class extends SubgraphClient {
 		};
 	}
 	async getVaultByAddress(vaultAddress, filter) {
-		const response = await this.searchVaults({
-			...filter,
-			vaultAddress
-		});
-		if (!response.success || !response.data) return {
+		const chainId = filter?.chainId;
+		const normalizedVaultAddress = this.normalizeAddress(vaultAddress);
+		if (!chainId) return {
 			data: null,
-			status: response.status,
-			success: response.success,
-			error: response.error
+			status: 400,
+			success: false,
+			error: "chainId is required for a direct vault address lookup"
 		};
-		return {
-			data: response.data[0] || null,
-			status: 200,
-			success: true
+		if (!normalizedVaultAddress || !isAddress(vaultAddress)) return {
+			data: null,
+			status: 400,
+			success: false,
+			error: "vaultAddress must be a valid EVM address"
 		};
+		try {
+			const chain = chainIdToName(chainId);
+			const subgraphUrl = chain ? steerSubgraphConfig[chain] : void 0;
+			if (!subgraphUrl) throw new Error(`No subgraph configured for chainId: ${chainId}`);
+			const node = await this.subgraphVaultClient.getVaultByAddress({
+				subgraphUrl,
+				chainId,
+				vaultAddress: normalizedVaultAddress
+			});
+			return {
+				data: node ? this.filterVaultNodes([node], {
+					...filter,
+					vaultAddress: normalizedVaultAddress
+				})[0] || null : null,
+				status: 200,
+				success: true
+			};
+		} catch (error) {
+			console.warn("Direct subgraph vault lookup failed, falling back to the API:", error);
+		}
+		try {
+			const response = await this.apiClient.vault({
+				id: normalizedVaultAddress,
+				chainId
+			});
+			const vault = response.data?.vault;
+			return {
+				data: vault ? this.filterVaultNodes([this.transformApiVaultNode(vault)], {
+					...filter,
+					vaultAddress: normalizedVaultAddress
+				})[0] || null : null,
+				status: response.status,
+				success: true
+			};
+		} catch (error) {
+			return {
+				data: null,
+				status: 500,
+				success: false,
+				error: error instanceof Error ? error.message : "Direct vault lookup failed"
+			};
+		}
 	}
 	async getVaultsForPool(poolAddress, filter) {
 		return this.searchVaults({