@steerprotocol/sdk 1.26.0 → 1.28.0

package/src/utils/SubgraphVaultClient.ts

@@ -0,0 +1,408 @@
+import { Address } from 'viem';
+import { VaultEdge, VaultNode, VaultsConnection } from '../base/VaultClient';
+import { getProtocolTypeByBeacon } from '../const';
+import { Protocol } from '../const/chain';
+import {
+  LpPriceResponse,
+  SubgraphResponse,
+  SubgraphVaultDetails,
+  SubgraphVaultDetailsWithLpData,
+  VaultFetchOptions,
+} from './subgraph-types';
+
+/**
+ * GraphQL queries for fetching vault data from Steer subgraphs
+ */
+const FIND_ALL_VAULTS = (batchSize: number = 1000, timestamp?: string) => {
+  if (timestamp) {
+    return `query {
+      vaults(first: ${batchSize}, where: { createdAt_lte: "${timestamp}" }, orderBy: createdAt, orderDirection: desc) {
+        id
+        name
+        token0
+        token1
+        pool
+        weeklyFeeAPR
+        token0Symbol
+        token0Decimals
+        token1Symbol
+        token1Decimals
+        totalValueLockedToken0
+        totalValueLockedToken1
+        token0Balance
+        token1Balance
+        totalLPTokensIssued
+        createdAt
+        feeTier
+        strategyToken {
+          id
+          name
+          creator {
+            id
+          }
+          admin
+          executionBundle
+        }
+        beaconName
+        payloadIpfs
+        deployer
+      }
+    }`;
+  }
+
+  return `query {
+    vaults(first: ${batchSize}, orderBy: createdAt, orderDirection: desc) {
+      id
+      name
+      token0
+      token1
+      pool
+      weeklyFeeAPR
+      token0Symbol
+      token0Decimals
+      token1Symbol
+      token1Decimals
+      totalValueLockedToken0
+      totalValueLockedToken1
+      token0Balance
+      token1Balance
+      totalLPTokensIssued
+      createdAt
+      feeTier
+      strategyToken {
+        id
+        name
+        creator {
+          id
+        }
+        admin
+        executionBundle
+      }
+      beaconName
+      payloadIpfs
+      deployer
+    }
+  }`;
+};
+
+const FIND_ALL_VAULTS_BY_PROTOCOL = (
+  batchSize: number = 1000,
+  timestamp?: string,
+  beaconNames?: string[]
+) => {
+  if (!beaconNames || beaconNames.length === 0) {
+    throw new Error('At least one beacon name is required');
+  }
+
+  // Format beaconNames for GraphQL _in filter
+  const beaconNamesList = beaconNames.map((b) => `"${b}"`).join(', ');
+  const beaconNameFilter = `beaconName_in: [${beaconNamesList}]`;
+
+  if (timestamp) {
+    return `query {
+      vaults(first: ${batchSize}, where: { createdAt_lte: "${timestamp}", ${beaconNameFilter} }, orderBy: createdAt, orderDirection: desc) {
+        id
+        name
+        token0
+        token1
+        pool
+        weeklyFeeAPR
+        token0Symbol
+        token0Decimals
+        token1Symbol
+        token1Decimals
+        totalValueLockedToken0
+        totalValueLockedToken1
+        token0Balance
+        token1Balance
+        totalLPTokensIssued
+        createdAt
+        feeTier
+        strategyToken {
+          id
+          name
+          creator {
+            id
+          }
+          admin
+          executionBundle
+        }
+        beaconName
+        payloadIpfs
+        deployer
+      }
+    }`;
+  }
+
+  return `query {
+    vaults(first: ${batchSize}, where: { ${beaconNameFilter} }, orderBy: createdAt, orderDirection: desc) {
+      id
+      name
+      token0
+      token1
+      pool
+      weeklyFeeAPR
+      token0Symbol
+      token0Decimals
+      token1Symbol
+      token1Decimals
+      totalValueLockedToken0
+      totalValueLockedToken1
+      token0Balance
+      token1Balance
+      totalLPTokensIssued
+      createdAt
+      feeTier
+      strategyToken {
+        id
+        name
+        creator {
+          id
+        }
+        admin
+        executionBundle
+      }
+      beaconName
+      payloadIpfs
+      deployer
+    }
+  }`;
+};
+
+/**
+ * Utility class for fetching vault data from Steer subgraphs
+ */
+export class SubgraphVaultClient {
+  private readonly SENTIO_API_KEY =
+    typeof process !== 'undefined' ? process.env?.SENTIO_API_KEY : undefined;
+
+  /**
+   * Transform subgraph vault data to match VaultClient interface
+   */
+  private transformSubgraphVaultToVaultNode(
+    vault: SubgraphVaultDetailsWithLpData,
+    chainId: number,
+    aprMap: Map<string, number>
+  ): VaultNode {
+    // Get the chain enum from chainId
+    const feeApr = aprMap.get(vault.id) ? aprMap.get(vault.id) : undefined;
+    return {
+      id: vault.id,
+      chainId,
+      vaultAddress: vault.id,
+      protocol: getProtocolTypeByBeacon(vault.beaconName) || Protocol.Uniswap,
+      beaconName: vault.beaconName,
+      protocolBaseType: this.getProtocolBaseType(vault.beaconName),
+      name: vault.name || '',
+      feeApr: feeApr ? parseFloat(feeApr.toString()) : undefined,
+      stakingApr: undefined, // Not available in subgraph
+      merklApr: undefined, // Not available in subgraph
+      pool: {
+        id: vault.pool,
+        poolAddress: vault.pool,
+        feeTier: vault.feeTier,
+        tick: undefined,
+        liquidity: undefined,
+        volumeUSD: undefined,
+        totalValueLockedUSD: vault.lpPriceData?.vault.usd.totalValue?.toString(),
+      },
+      token0: {
+        id: vault.token0,
+        symbol: vault.token0Symbol,
+        name: vault.token0Symbol, // Using symbol as name since name is not available
+        decimals: parseInt(vault.token0Decimals),
+        address: vault.token0,
+        chainId,
+      },
+      token1: {
+        id: vault.token1,
+        symbol: vault.token1Symbol,
+        name: vault.token1Symbol, // Using symbol as name since name is not available
+        decimals: parseInt(vault.token1Decimals),
+        address: vault.token1,
+        chainId,
+      },
+    };
+  }
+
+  /**
+   * Get protocol base type from beacon name
+   */
+  private getProtocolBaseType(beaconName: string): string {
+    if (beaconName.includes('uniswap')) {
+      return 'UniswapV3';
+    }
+    const protocol = getProtocolTypeByBeacon(beaconName);
+    if (protocol) {
+      return protocol === Protocol.Blackhole ? 'Algebra Integral' : protocol;
+    }
+    if (beaconName.includes('Stryke')) {
+      return 'Stryke';
+    }
+    return 'UniswapV3'; // Default
+  }
+
+  /**
+   * Create a mock LP price response for vaults without LP data
+   */
+  private createMockLpPriceData(vault: SubgraphVaultDetails): LpPriceResponse {
+    return {
+      vault: {
+        address: vault.id as Address,
+        token0: vault.token0 as Address,
+        token1: vault.token1 as Address,
+        balances: {
+          token0: vault.token0Balance,
+          token1: vault.token1Balance,
+          totalSupply: vault.totalLPTokensIssued,
+          token0Formatted: vault.token0Balance,
+          token1Formatted: vault.token1Balance,
+          totalSupplyFormatted: vault.totalLPTokensIssued,
+        },
+        usd: {
+          lpValue: 0,
+          totalValue: 0,
+          token0Price: 0,
+          token0Value: 0,
+          token1Price: 0,
+          token1Value: 0,
+        },
+        token0Symbol: vault.token0Symbol,
+        token1Symbol: vault.token1Symbol,
+        token0Decimals: vault.token0Decimals,
+        token1Decimals: vault.token1Decimals,
+      },
+      routes: {
+        token0ToUsd: [],
+        token1ToUsd: [],
+      },
+    };
+  }
+
+  /**
+   * Fetch vault data from subgraph
+   */
+  public async getAllVaultsFromSubgraph(
+    options: VaultFetchOptions
+  ): Promise<SubgraphVaultDetailsWithLpData[]> {
+    const { subgraphUrl, showCurrentProtocol = false, beaconNames, batchSize = 1000 } = options;
+
+    const allVaults: SubgraphVaultDetailsWithLpData[] = [];
+
+    try {
+      // First get the latest vault to get the most recent timestamp
+      const latestVaultResponse = 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: !showCurrentProtocol
+            ? FIND_ALL_VAULTS(1)
+            : FIND_ALL_VAULTS_BY_PROTOCOL(1, undefined, beaconNames),
+          variables: {},
+        }),
+      });
+
+      const latestVaultData: SubgraphResponse<SubgraphVaultDetails> =
+        await latestVaultResponse.json();
+      let lastTimestamp = latestVaultData?.data?.vaults?.[0]?.createdAt;
+
+      let hasMoreData = true;
+      while (hasMoreData) {
+        const response = 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: !showCurrentProtocol
+              ? FIND_ALL_VAULTS(batchSize, lastTimestamp)
+              : FIND_ALL_VAULTS_BY_PROTOCOL(batchSize, lastTimestamp, beaconNames),
+            variables: {},
+          }),
+        });
+
+        const responseData: SubgraphResponse<SubgraphVaultDetails> = await response.json();
+        const vaults = responseData?.data?.vaults || [];
+
+        if (!vaults.length) {
+          hasMoreData = false;
+        }
+
+        // Filter out duplicates based on vault ID
+        const newVaults = vaults.filter(
+          (vault: SubgraphVaultDetails) => !allVaults.some((existing) => existing.id === vault.id)
+        );
+
+        if (!newVaults.length) {
+          hasMoreData = false;
+        }
+
+        // For now, attach mock LP data to each vault
+        // In a real implementation, you would fetch LP price data here
+        const vaultsWithLpData: SubgraphVaultDetailsWithLpData[] = newVaults.map((vault) => ({
+          ...vault,
+          lpPriceData: this.createMockLpPriceData(vault),
+        }));
+
+        allVaults.push(...vaultsWithLpData);
+        lastTimestamp = vaults[vaults.length - 1].createdAt;
+      }
+
+      // Filter deprecated vaults if needed
+      // Note: In a real implementation, you would fetch deprecation data
+      // For now, we return all vaults
+      return allVaults;
+    } catch (error) {
+      console.error('Error fetching vaults from subgraph:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Transform subgraph vault data to VaultsConnection format
+   */
+  public transformToVaultsConnection(
+    vaults: SubgraphVaultDetailsWithLpData[],
+    chainId: number,
+    first: number = 50,
+    aprMap: Map<string, number>,
+    after?: string | null
+  ): VaultsConnection {
+    // Sort vaults by creation time (newest first)
+    const sortedVaults = vaults.sort((a, b) => parseInt(b.createdAt) - parseInt(a.createdAt));
+
+    // Apply pagination
+    let startIndex = 0;
+    if (after) {
+      const afterIndex = sortedVaults.findIndex((vault) => vault.id === after);
+      startIndex = afterIndex + 1;
+    }
+
+    const paginatedVaults = sortedVaults.slice(startIndex, startIndex + first);
+    const hasNextPage = startIndex + first < sortedVaults.length;
+    const endCursor =
+      paginatedVaults.length > 0 ? paginatedVaults[paginatedVaults.length - 1].id : null;
+
+    const edges: VaultEdge[] = paginatedVaults.map((vault) => ({
+      cursor: vault.id,
+      node: this.transformSubgraphVaultToVaultNode(vault, chainId, aprMap),
+    }));
+
+    return {
+      edges,
+      pageInfo: {
+        hasNextPage,
+        endCursor,
+      },
+      totalCount: sortedVaults.length,
+    };
+  }
+}

package/src/utils/subgraph-types.ts

@@ -0,0 +1,108 @@
+import { Address } from 'viem';
+
+/**
+ * Types for Steer subgraph responses
+ */
+
+export interface SubgraphVaultDetails {
+  id: string;
+  name: string;
+  token0: string;
+  token1: string;
+  pool: string;
+  weeklyFeeAPR: string;
+  token0Symbol: string;
+  token0Decimals: string;
+  token1Symbol: string;
+  token1Decimals: string;
+  totalValueLockedToken0: string;
+  totalValueLockedToken1: string;
+  token0Balance: string;
+  token1Balance: string;
+  totalLPTokensIssued: string;
+  createdAt: string;
+  feeTier: string;
+  strategyToken: {
+    id: string;
+    name: string;
+    creator: {
+      id: string;
+    };
+    admin: string;
+    executionBundle: string;
+  };
+  beaconName: string;
+  payloadIpfs: string;
+  deployer: string;
+}
+
+
+export interface RouteShortcut {
+  poolIds: string[]
+  tokenPath: string[]
+}
+
+export interface FormattedRoute {
+  path: string
+  pricesPerHop: string
+  finalPrice: string
+  finalPriceRaw: number
+  volumeScore: string
+  poolVolumes: string
+  shortcut: RouteShortcut
+}
+export interface LpPriceResponse {
+  vault: {
+    address: Address;
+    token0: Address;
+    token1: Address;
+    balances: {
+      token0: string;
+      token1: string;
+      totalSupply: string;
+      token0Formatted: string;
+      token1Formatted: string;
+      totalSupplyFormatted: string;
+    };
+    usd: {
+      lpValue: number;
+      totalValue: number;
+      token0Price: number;
+      token0Value: number;
+      token1Price: number;
+      token1Value: number;
+    };
+    token0Symbol: string;
+    token1Symbol: string;
+    token0Decimals: string;
+    token1Decimals: string;
+  };
+  routes: {
+    token0ToUsd: FormattedRoute[];
+    token1ToUsd: FormattedRoute[];
+  };
+}
+
+export interface SubgraphVaultDetailsWithLpData extends SubgraphVaultDetails {
+  lpPriceData?: LpPriceResponse;
+}
+
+export interface SubgraphResponse<T> {
+  data: {
+    vaults: T[];
+  };
+}
+
+export interface DeprecationData {
+  id: string;
+  visible: boolean;
+}
+
+export interface VaultFetchOptions {
+  subgraphUrl: string;
+  chainId: number;
+  showDeprecated?: boolean;
+  showCurrentProtocol?: boolean;
+  beaconNames?: string[];
+  batchSize?: number;
+}