@steerprotocol/sdk 1.30.8 → 1.31.0

package/src/base/PoolClient.ts

@@ -67,10 +67,18 @@ export interface PoolFilter {
   chainId?: number;
   /** Protocol to filter pools by */
   protocol?: Protocol;
+  /** Exact pool address/id to look up */
+  poolAddress?: string;
   /** Minimum volume in USD to filter pools */
   minVolumeUSD?: number;
   /** Token address to find pools containing this token */
   tokenAddress?: string;
+  /** Multiple token addresses to find pools for */
+  tokenAddresses?: string[];
+  /** Token symbol to find pools containing this token */
+  tokenSymbol?: string;
+  /** Multiple token symbols to find pools for */
+  tokenSymbols?: string[];
   /** Maximum number of pools to return */
   limit?: number;
 }
@@ -207,6 +215,93 @@ export class PoolClient extends SubgraphClient {
     };
   }
 
+  private normalizeAddress(value?: string): string {
+    return value?.toLowerCase() || '';
+  }
+
+  private normalizeSymbol(value?: string): string {
+    return value?.trim().toLowerCase() || '';
+  }
+
+  private dedupePools(pools: GraphQLPoolData[]): GraphQLPoolData[] {
+    const seen = new Set<string>();
+    const deduped: GraphQLPoolData[] = [];
+
+    pools.forEach((pool) => {
+      const key = this.normalizeAddress(pool.id);
+      if (!key || seen.has(key)) {
+        return;
+      }
+
+      seen.add(key);
+      deduped.push(pool);
+    });
+
+    return deduped;
+  }
+
+  private filterPoolsBySymbols(
+    pools: GraphQLPoolData[],
+    symbols: string[],
+  ): GraphQLPoolData[] {
+    if (symbols.length === 0) {
+      return pools;
+    }
+
+    const normalizedSymbols = new Set(
+      symbols.map((symbol) => this.normalizeSymbol(symbol)).filter(Boolean),
+    );
+
+    return pools.filter((pool) => {
+      const token0Symbol = this.normalizeSymbol(pool.token0?.symbol);
+      const token1Symbol = this.normalizeSymbol(pool.token1?.symbol);
+
+      return normalizedSymbols.has(token0Symbol) || normalizedSymbols.has(token1Symbol);
+    });
+  }
+
+  private applyPoolSearchResultFilters(
+    pools: GraphQLPoolData[],
+    filter: PoolFilter,
+  ): GraphQLPoolData[] {
+    let filteredPools = this.dedupePools(pools);
+
+    if (typeof filter.minVolumeUSD === 'number') {
+      filteredPools = filteredPools.filter((pool) => {
+        const volumeUSD = parseFloat(pool.volumeUSD || pool.volumeUsd || '0');
+        return !Number.isNaN(volumeUSD) && volumeUSD >= filter.minVolumeUSD!;
+      });
+    }
+
+    if (typeof filter.limit === 'number' && filter.limit >= 0) {
+      filteredPools = filteredPools.slice(0, filter.limit);
+    }
+
+    return filteredPools;
+  }
+
+  private async searchPoolsBySymbols(
+    filter: Required<Pick<PoolFilter, 'chainId' | 'protocol'>> & PoolFilter,
+    symbols: string[],
+  ): Promise<SteerResponse<GraphQLPoolData[]>> {
+    // Symbol relation filtering is not portable across all supported AMM subgraphs.
+    // Use bounded top-pools fetch plus local symbol filtering as the baseline path.
+    const boundedLimit = Math.min(Math.max(filter.limit ?? 200, 1), 500);
+    const topPools = await this.getTopPools(boundedLimit, filter.protocol, filter.chainId);
+
+    if (!topPools.success || !topPools.data) {
+      return topPools;
+    }
+
+    const symbolMatches = this.filterPoolsBySymbols(topPools.data, symbols);
+
+    return {
+      data: this.applyPoolSearchResultFilters(symbolMatches, filter),
+      status: 200,
+      success: true,
+    };
+  }
+
   /**
    * Fetches data from GraphQL endpoint with retry logic for rate limits
    * 
@@ -675,4 +770,108 @@ export class PoolClient extends SubgraphClient {
       return true;
     });
   }
-} 
+
+  /**
+   * Searches pools using exact-address lookups where supported and local symbol
+   * filtering as a portable fallback.
+   *
+   * Symbol-based matching is best-effort because not every downstream AMM
+   * subgraph exposes portable nested token-symbol filters.
+   */
+  public async searchPools(
+    filter: PoolFilter,
+  ): Promise<SteerResponse<GraphQLPoolData[]>> {
+    const { chainId, protocol } = filter;
+
+    if (!chainId || !protocol) {
+      return {
+        data: null,
+        status: 400,
+        success: false,
+        error: 'searchPools requires both chainId and protocol',
+      };
+    }
+
+    const normalizedPoolAddress = this.normalizeAddress(filter.poolAddress);
+    const normalizedTokenAddress = this.normalizeAddress(filter.tokenAddress);
+    const normalizedTokenAddresses = (filter.tokenAddresses || [])
+      .map((address) => this.normalizeAddress(address))
+      .filter(Boolean);
+    const tokenSymbols = [
+      ...(filter.tokenSymbol ? [filter.tokenSymbol] : []),
+      ...(filter.tokenSymbols || []),
+    ].filter(Boolean);
+
+    if (
+      !normalizedPoolAddress &&
+      !normalizedTokenAddress &&
+      normalizedTokenAddresses.length === 0 &&
+      tokenSymbols.length === 0
+    ) {
+      return {
+        data: null,
+        status: 400,
+        success: false,
+        error: 'searchPools requires at least one of poolAddress, tokenAddress, tokenAddresses, tokenSymbol, or tokenSymbols',
+      };
+    }
+
+    const collectedPools: GraphQLPoolData[] = [];
+
+    if (normalizedPoolAddress) {
+      const exactPool = await this.getPoolById(normalizedPoolAddress, protocol, chainId);
+      if (!exactPool.success) {
+        return {
+          data: null,
+          status: exactPool.status,
+          success: false,
+          error: exactPool.error,
+        };
+      }
+
+      if (exactPool.data) {
+        collectedPools.push(exactPool.data);
+      }
+    }
+
+    if (normalizedTokenAddress) {
+      const tokenPools = await this.fetchPoolsForToken(normalizedTokenAddress, protocol, chainId);
+      if (!tokenPools.success) {
+        return tokenPools;
+      }
+
+      collectedPools.push(...(tokenPools.data || []));
+    }
+
+    if (normalizedTokenAddresses.length > 0) {
+      const batchPools = await this.fetchPoolsForTokensBatch(
+        normalizedTokenAddresses,
+        protocol,
+        chainId,
+      );
+      if (!batchPools.success) {
+        return batchPools;
+      }
+
+      collectedPools.push(...(batchPools.data || []));
+    }
+
+    if (tokenSymbols.length > 0) {
+      const symbolPools = await this.searchPoolsBySymbols(
+        { ...filter, chainId, protocol },
+        tokenSymbols,
+      );
+      if (!symbolPools.success) {
+        return symbolPools;
+      }
+
+      collectedPools.push(...(symbolPools.data || []));
+    }
+
+    return {
+      data: this.applyPoolSearchResultFilters(collectedPools, filter),
+      status: 200,
+      success: true,
+    };
+  }
+}

package/src/base/VaultClient.ts

@@ -218,6 +218,12 @@ export interface VaultFilter {
   protocol?: string;
   isActive?: boolean;
   beaconName?: string;
+  poolAddress?: string;
+  vaultAddress?: string;
+  tokenAddress?: string;
+  tokenAddresses?: string[];
+  tokenSymbol?: string;
+  tokenSymbols?: string[];
 }
 
 // API-specific filter that excludes protocol field
@@ -225,6 +231,7 @@ export interface ApiVaultFilter {
   chainId?: number;
   isActive?: boolean;
   beaconName?: string;
+  pool?: string;
 }
 
 export interface TokenFilter {
@@ -464,8 +471,16 @@ export class VaultClient extends SubgraphClient {
       return undefined;
     }
 
-    const { protocol, ...rest } = filter;
-    const apiFilter: ApiVaultFilter = { ...rest };
+    const { protocol, poolAddress, chainId, isActive, beaconName } = filter;
+    const apiFilter: ApiVaultFilter = {
+      chainId,
+      isActive,
+      beaconName,
+    };
+
+    if (poolAddress) {
+      apiFilter.pool = poolAddress;
+    }
 
     if (!apiFilter.beaconName && protocol) {
       const primaryBeaconName = this.getPrimaryProtocolBeaconName(protocol);
@@ -522,6 +537,88 @@ export class VaultClient extends SubgraphClient {
     };
   }
 
+  private normalizeAddress(value?: string): string {
+    return value?.toLowerCase() || '';
+  }
+
+  private normalizeSymbol(value?: string): string {
+    return value?.trim().toLowerCase() || '';
+  }
+
+  private matchesAnyAddress(candidates: Array<string | undefined>, filterValues: string[]): boolean {
+    if (filterValues.length === 0) {
+      return true;
+    }
+
+    const normalizedCandidates = new Set(
+      candidates.map((candidate) => this.normalizeAddress(candidate)).filter(Boolean),
+    );
+
+    return filterValues.some((value) => normalizedCandidates.has(value));
+  }
+
+  private matchesAnySymbol(candidates: Array<string | undefined>, filterValues: string[]): boolean {
+    if (filterValues.length === 0) {
+      return true;
+    }
+
+    const normalizedCandidates = new Set(
+      candidates.map((candidate) => this.normalizeSymbol(candidate)).filter(Boolean),
+    );
+
+    return filterValues.some((value) => normalizedCandidates.has(value));
+  }
+
+  private filterVaultNodes(vaults: VaultNode[], filter: VaultFilter): VaultNode[] {
+    const vaultAddress = this.normalizeAddress(filter.vaultAddress);
+    const poolAddress = this.normalizeAddress(filter.poolAddress);
+    const tokenAddressFilters = [
+      ...(filter.tokenAddress ? [filter.tokenAddress] : []),
+      ...(filter.tokenAddresses || []),
+    ]
+      .map((address) => this.normalizeAddress(address))
+      .filter(Boolean);
+    const tokenSymbolFilters = [
+      ...(filter.tokenSymbol ? [filter.tokenSymbol] : []),
+      ...(filter.tokenSymbols || []),
+    ]
+      .map((symbol) => this.normalizeSymbol(symbol))
+      .filter(Boolean);
+
+    return vaults.filter((vault) => {
+      if (vaultAddress && this.normalizeAddress(vault.vaultAddress) !== vaultAddress) {
+        return false;
+      }
+
+      if (
+        poolAddress &&
+        !this.matchesAnyAddress([vault.pool.poolAddress, vault.pool.id], [poolAddress])
+      ) {
+        return false;
+      }
+
+      if (
+        !this.matchesAnyAddress(
+          [vault.token0.address, vault.token0.id, vault.token1.address, vault.token1.id],
+          tokenAddressFilters,
+        )
+      ) {
+        return false;
+      }
+
+      if (
+        !this.matchesAnySymbol(
+          [vault.token0.symbol, vault.token1.symbol],
+          tokenSymbolFilters,
+        )
+      ) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
   /**
    * Gets vaults with pagination support
    * Fetches ALL data from both API (database) and subgraph in parallel, merges without duplicates, then paginates
@@ -1414,6 +1511,76 @@ export class VaultClient extends SubgraphClient {
     }
   }
 
+  /**
+   * Searches vaults by combining verified API-supported filters with local
+   * filtering over the merged vault result set for unsupported server-side fields.
+   */
+  public async searchVaults(
+    filter?: VaultFilter,
+  ): Promise<SteerResponse<VaultNode[]>> {
+    const response = await this.getAllVaults(filter);
+
+    if (!response.success || !response.data) {
+      return response;
+    }
+
+    return {
+      data: this.filterVaultNodes(response.data, filter || {}),
+      status: 200,
+      success: true,
+    };
+  }
+
+  public async getVaultByAddress(
+    vaultAddress: string,
+    filter?: VaultFilter,
+  ): Promise<SteerResponse<VaultNode | null>> {
+    const response = await this.searchVaults({
+      ...filter,
+      vaultAddress,
+    });
+
+    if (!response.success || !response.data) {
+      return {
+        data: null,
+        status: response.status,
+        success: response.success,
+        error: response.error,
+      };
+    }
+
+    return {
+      data: response.data[0] || null,
+      status: 200,
+      success: true,
+    };
+  }
+
+  public async getVaultsForPool(
+    poolAddress: string,
+    filter?: VaultFilter,
+  ): Promise<SteerResponse<VaultNode[]>> {
+    return this.searchVaults({
+      ...filter,
+      poolAddress,
+    });
+  }
+
+  public async getVaultsForToken(
+    tokenAddressOrSymbol: string,
+    filter?: VaultFilter,
+  ): Promise<SteerResponse<VaultNode[]>> {
+    const normalizedValue = tokenAddressOrSymbol.trim();
+    const isAddress = /^0x[a-fA-F0-9]{40}$/.test(normalizedValue);
+
+    return this.searchVaults({
+      ...filter,
+      ...(isAddress
+        ? { tokenAddress: normalizedValue }
+        : { tokenSymbol: normalizedValue }),
+    });
+  }
+
   /**
    * Gets APR data for vaults from the Steer Finance API
    * @param filter - Filter containing chainId and protocol

package/src/const/feeManagerContracts.ts

@@ -0,0 +1,28 @@
+// This file is generated from @steerprotocol/contracts deployment JSON.
+// It is intentionally scoped to FeeManager addresses only.
+export interface FeeManagerDeployment {
+  address: string;
+  startBlock?: number;
+}
+
+export const feeManagerContractsByChainId: Record<number, FeeManagerDeployment> = {
+  14: { address: '0xb944789b5C962f1096Ce8674456E68fb0F2e3BB7' },
+  30: { address: '0xAa4448AeF5f5967693751BFB67197946BB6D1dC0' },
+  40: { address: '0xE431A1dE6F37cD08AAA8821F83bD2157857E8172' },
+  146: { address: '0x51aC65B177F084455750131A81706C32b466101D' },
+  199: { address: '0xdca3251Ebe8f85458E8d95813bCb816460e4bef1' },
+  314: { address: '0x0C5c5BEB833fD382b04e039f151942DC3D9A60ce' },
+  1284: { address: '0xfF42cD42d8a5812CB38fb3C0720Dfc490912f48B' },
+  1301: { address: '0xEd3420D9A8D42FAA8D054D284ed2bdd17a6Bca2b' },
+  1329: { address: '0x9790aFEc5d23a840bC0597D9F54584057254d190' },
+  8453: { address: '0xac4D51669B80D09d8Cc5EeFF50026c4d1D3290e6' },
+  33139: { address: '0xd47CE509bE01e62cd4629E2f1eb22BA04e7dA192' },
+  34443: { address: '0x7Daa68204232a78dBF1Dd853a4018330EE934A39' },
+  43114: { address: '0x391cf3047db983caB8dD95B16c4e6C3918d72d23' },
+  48900: { address: '0x0C5c5BEB833fD382b04e039f151942DC3D9A60ce' },
+  59144: { address: '0xBcD427Ff26b70E73149858C4898DFa60107bedBe' },
+  80084: { address: '0x0D3Ea88C8C3cb26EF21ab9E9ac6D178602Ef2779' },
+  81457: { address: '0x7Daa68204232a78dBF1Dd853a4018330EE934A39' },
+  167000: { address: '0x254d37F5eD7E96fc2d242CB06B17FAe1EE9E1ADA' },
+  534352: { address: '0xa4a2f232C92f2DE7181E9fe4d46297FbBb4afaaA' },
+};

package/src/const/network.ts

@@ -11,6 +11,7 @@ import { peaqAddresses } from "./deployments/peaq.js";
 import { roninAddresses } from "./deployments/ronin.js";
 import { nibiruAddresses } from "./deployments/nibiru.js";
 import { hyperevmAddresses } from "./deployments/hyperevm.js";
+import { feeManagerContractsByChainId } from './feeManagerContracts.js';
 
 /**
  * Interface representing a smart contract with its address and optional start block
@@ -56,6 +57,7 @@ export interface ContractAddresses {
   Helper?:Contract
 
   SingleAssetDeposit?:Contract
+  FeeManager?: Contract
 }
 
 /**
@@ -538,6 +540,13 @@ export const networks: Networks = {
   }
 };
 
+for (const network of Object.values(networks) as NetworkConfig[]) {
+  const feeManagerDeployment = feeManagerContractsByChainId[network.chainId];
+  if (feeManagerDeployment) {
+    network.FeeManager = feeManagerDeployment;
+  }
+}
+
 
 /**
  * Retrieves a contract address for a specific chain ID and contract name.
@@ -632,4 +641,4 @@ export function isSingleAssetDepositSupported(chainId: number) {
   const supportedChains = [ChainId.Polygon, ChainId.Hyperevm, ChainId.Peaq, ChainId.Arbitrum, ChainId.Katana, ChainId.Base, ChainId.Saga, ChainId.Mainnet, ChainId.Nibiru];
 
   return supportedChains.indexOf(chainId) > -1;
-}
+}

package/src/const/protocol.ts

@@ -1,6 +1,6 @@
-import { AMMType } from '../base/vault/single-asset/types';
-import { SupportedProtocol, ProtocolInfo } from '../types';
-import { Protocol, Chain } from './chain';
+import { AMMType } from '../base/vault/single-asset/types.js';
+import { SupportedProtocol } from '../types.js';
+import { Protocol } from './chain.js';
 
 /**
  * Enum representing supported staking protocols
@@ -30,10 +30,15 @@ export enum StakingProtocol {
  * }
  * ```
  */
-export function isValidStakingProtocol(protocol: string): protocol is StakingProtocol {
-  // Convert the input protocol to title case (first letter uppercase, rest lowercase)
-  const normalizedProtocol = protocol.charAt(0).toUpperCase() + protocol.slice(1).toLowerCase();
-  return Object.values(StakingProtocol).includes(normalizedProtocol as StakingProtocol);
+export function isValidStakingProtocol(protocol: string | null | undefined): protocol is StakingProtocol {
+  if (!protocol || typeof protocol !== 'string') {
+    return false;
+  }
+
+  const normalizedProtocol = Object.values(StakingProtocol).find(
+    (value) => value.toLowerCase() === protocol.toLowerCase(),
+  );
+  return Boolean(normalizedProtocol);
 }
 
 /**
@@ -49,11 +54,13 @@ export function isValidStakingProtocol(protocol: string): protocol is StakingPro
  * ```
  */
 export function normalizeProtocol(protocol: string): StakingProtocol {
-  const normalizedProtocol = protocol.charAt(0).toUpperCase() + protocol.slice(1).toLowerCase();
-  if (!isValidStakingProtocol(normalizedProtocol)) {
+  const normalizedProtocol = Object.values(StakingProtocol).find(
+    (value) => value.toLowerCase() === protocol.toLowerCase(),
+  );
+  if (!normalizedProtocol || !isValidStakingProtocol(normalizedProtocol)) {
     throw new Error(`Invalid protocol: ${protocol}`);
   }
-  return normalizedProtocol as StakingProtocol;
+  return normalizedProtocol;
 }
 
 /**
@@ -229,32 +236,4 @@ export const getProtcolTypeByAmmType = (ammType: AMMType): Protocol => {
   }
 
   throw Error('Protocol type not found')
-}
-
-/**
- * Checks if a protocol supports algebraHook for a given chain.
- *
- * @param protocolInfo - The protocol information object
- * @param chain - The chain to check for algebraHook support
- * @returns True if the protocol supports algebraHook on the given chain, false otherwise
- * @example
- * ```typescript
- * const protocolInfo = `getProtocolInfoBy`Name('QuickSwapIntegral', 'api-key');
- * if (isAlgebraHookSupported(protocolInfo, Chain.Base)) {
- *   // Protocol supports algebraHook on Base chain
- * }
- * ```
- */
-export const isAlgebraHookSupported = (protocolInfo: ProtocolInfo | undefined, chain: Chain): boolean => {
-  if (!protocolInfo) {
-    return false;
-  }
-  
-  // Check if the protocol has algebraHook supported chains defined
-  if (protocolInfo.algebraHookSupportedChains && Array.isArray(protocolInfo.algebraHookSupportedChains)) {
-    return protocolInfo.algebraHookSupportedChains.includes(chain);
-  }
-  
-  // Fallback: if no specific chains are defined but beaconAlgebraHook exists, assume it's supported
-  return !!protocolInfo.beaconAlgebraHook;
-} 
+} 

package/src/scripts/processDeployments.ts

@@ -47,6 +47,7 @@ const WHITELISTED_CONTRACTS = [
   'SteerPeriphery',
   'StrategyRegistry',
   'VaultRegistry',
+  'FeeManager',
   "Orchestrator",
   "BundleRegistry",
   // 'Helper',