@steerprotocol/sdk 1.27.0 → 1.28.0

package/src/const/amm/utils/contracts.ts

@@ -0,0 +1,162 @@
+import { SupportedProtocol } from '../../../types.js';
+import { Chain } from '../../chain.js';
+import { getAmmConfig } from '../configs/ammConfig.js';
+
+/**
+ * Retrieves the swap router contract address for a given protocol and chain.
+ * 
+ * @param protocol - The supported protocol to get the router address for
+ * @param chain - The blockchain network
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns The swap router contract address or undefined if not found
+ */
+export function getSwapRouterAddress(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.swapRouterAddress?.[chain];
+}
+
+/**
+ * Gets the init code hash for a given protocol and chain.
+ * 
+ * @param protocol - The supported protocol to get the init code hash for
+ * @param chain - The blockchain network
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns The init code hash or undefined if not found
+ */
+export function getQuoterV2Address(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.QuoterV2Address?.[chain];
+}
+
+
+
+export function getInitCodeHash(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.initCodeHash?.[chain];
+}
+
+
+/**
+ * Retrieves the factory contract address for a given protocol and chain.
+ * 
+ * @param protocol - The supported protocol to get the factory address for
+ * @param chain - The blockchain network
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns The factory contract address or undefined if not found
+ */
+export function getFactoryAddress(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.factoryAddress?.[chain];
+}
+
+/**
+ * Gets the tick lens contract address for a given protocol and chain.
+ * 
+ * @param protocol - The supported protocol to get the tick lens address for
+ * @param chain - The blockchain network
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns The tick lens contract address or undefined if not found
+ */
+export function getTickLensAddress(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.TickLensAddress?.[chain];
+}
+
+/**
+ * Retrieves the NFT manager contract address for a given protocol and chain.
+ * 
+ * @param protocol - The supported protocol to get the NFT manager address for
+ * @param chain - The blockchain network
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns The NFT manager contract address or undefined if not found
+ */
+export function getNFTManagerAddress(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.NFTManagerAddress?.[chain];
+}
+
+/**
+ * Gets the subgraph URL for a given protocol and chain.
+ * 
+ * @param protocol - The supported protocol to get the subgraph URL for
+ * @param chain - The blockchain network
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns The subgraph URL string
+ * @throws Error if subgraph URL is not found
+ */
+export function getProtocolSubgraphURL(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string {
+  const url = getAmmConfig(theGraphApiKey)[protocol]?.subgraph?.[chain];
+  if (url) {
+    return url;
+  }
+
+  throw new Error(`Subgraph URL not found for ${protocol} on ${chain}`);
+}
+
+/**
+ * Interface representing all contract addresses for a protocol
+ */
+export type ProtocolContractAddresses = {
+  swapRouterAddress: string | undefined;
+  NFTManagerAddress: string | undefined;
+  UniswapV3Factory: string | undefined;
+  TickLensAddress: string | undefined;
+  initCodeHash: string | undefined;
+  quoterV2Address: string | undefined
+}
+
+/**
+ * Retrieves all relevant contract addresses for a given protocol and chain.
+ * 
+ * @param protocol - The supported protocol to get the contract addresses for
+ * @param chain - The blockchain network
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns An object containing all contract addresses
+ * @example
+ * ```typescript
+ * const addresses = getProtocolContractAddresses('Uniswap', Chain.MAINNET, 'api-key');
+ * ```
+ */
+export function getProtocolContractAddresses(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): ProtocolContractAddresses {
+  const swapRouterAddress = getSwapRouterAddress(protocol, chain, theGraphApiKey);
+  const NFTManagerAddress = getNFTManagerAddress(protocol, chain, theGraphApiKey);
+  const UniswapV3Factory = getFactoryAddress(protocol, chain, theGraphApiKey);
+  const TickLensAddress = getTickLensAddress(protocol, chain, theGraphApiKey);
+  const initCodeHash = getInitCodeHash(protocol, chain, theGraphApiKey);
+  const quoterV2Address = getQuoterV2Address(protocol, chain, theGraphApiKey);
+
+  return {
+    swapRouterAddress,
+    NFTManagerAddress,
+    UniswapV3Factory,
+    TickLensAddress,
+    initCodeHash,
+    quoterV2Address
+  };
+} 

package/src/const/amm/utils/index.ts

@@ -0,0 +1,127 @@
+import { AMMConfigType, ProtocolInfo, SupportedProtocol } from '../../../types.js';
+import { Chain } from '../../chain.js';
+import { chainIdToName } from '../../network.js';
+import { getAmmConfig } from '../configs/ammConfig.js';
+
+export const getAmmConfigByChainId = (chainId: number, theGraphApiKey: string): AMMConfigType => {
+  const chainName = chainIdToName(chainId);
+  const config = getAmmConfig(theGraphApiKey);
+
+  if (!chainName) {
+    throw new Error(`Chain ${chainId} not supported`);
+  }
+
+  const chainEnum = Chain[chainName as keyof typeof Chain];
+
+  // Filter protocols that support the specified chain
+  const filteredConfig: Partial<AMMConfigType> = {};
+
+  for (const protocol in config) {
+    const protocolConfig = config[protocol as SupportedProtocol];
+    if (!protocolConfig) continue;
+
+    // Check if this protocol supports the specified chain in any of its configurations
+    const hasChainSupport = Object.values(protocolConfig).some((configSection) => {
+      if (typeof configSection === 'object' && configSection !== null) {
+        return chainEnum in configSection;
+      }
+      return false;
+    });
+
+    // If the protocol supports this chain, include it in the filtered config but only with the specified chain
+    if (hasChainSupport) {
+      // Create a new protocol config with only the specified chain
+      const filteredProtocolConfig: ProtocolInfo = {
+        subgraph: {},
+        factoryAddress: {},
+      };
+
+      // For each section in the protocol config (subgraph, factoryAddress, etc.)
+      for (const sectionKey in protocolConfig) {
+        const section = protocolConfig[sectionKey as keyof typeof protocolConfig];
+
+        // If this section is an object with chain mappings
+        if (typeof section === 'object' && section !== null) {
+          // Create a new section with only the specified chain
+          const filteredSection: Record<Chain, string> = {} as Record<Chain, string>;
+
+          // If this chain exists in this section, include only that chain
+          if (chainEnum in section) {
+            filteredSection[chainEnum] = section[chainEnum as keyof typeof section] as string;
+
+            // Add this filtered section to the filtered protocol config
+            (filteredProtocolConfig[sectionKey as keyof ProtocolInfo] as Record<Chain, string>) =
+              filteredSection;
+          }
+        } else if (section !== undefined) {
+          // For non-object sections (like beaconContract), include as is
+          (filteredProtocolConfig as Record<keyof ProtocolInfo, unknown>)[sectionKey as keyof ProtocolInfo] = section;
+        }
+      }
+
+      filteredConfig[protocol as SupportedProtocol] = filteredProtocolConfig;
+    }
+  }
+
+  return filteredConfig as AMMConfigType;
+};
+
+
+export function getFactoryAddress(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.factoryAddress?.[chain];
+}
+
+export function getTickLensAddress(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.TickLensAddress?.[chain];
+}
+
+export function getNFTManagerAddress(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.NFTManagerAddress?.[chain];
+}
+
+export function getProtocolSubgraphURL(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string {
+  const url = getAmmConfig(theGraphApiKey)[protocol]?.subgraph?.[chain];
+  if (url) {
+    return url;
+  }
+
+  throw new Error(`Subgraph URL not found for ${protocol} on ${chain}`);
+}
+
+export function getSwapRouterAddress(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.swapRouterAddress?.[chain];
+}
+
+export function getInitCodeHash(
+  protocol: SupportedProtocol,
+  chain: Chain,
+  theGraphApiKey: string
+): string | undefined {
+  return getAmmConfig(theGraphApiKey)[protocol]?.initCodeHash?.[chain];
+}
+
+
+export * from './beacon.js';
+export * from './contracts.js';
+export * from './protocol.js';
+

package/src/const/amm/utils/protocol.ts

@@ -0,0 +1,171 @@
+import { ProtocolInfo, SupportedProtocol } from '../../../types.js';
+import { Chain, Protocol } from '../../chain.js';
+import { chainIdToName } from '../../network.js';
+import { ALGEBRA_PROTOCOLS } from '../../protocol.js';
+import { getAmmConfig } from '../configs/ammConfig.js';
+
+/**
+` * Interface representing detailed protocol information including name and associated data
+ */
+export type ProtocolDetails = {
+  /** The protocol identifier */
+  name: SupportedProtocol;
+  /** Protocol-specific configuration and information */
+  data: ProtocolInfo;
+}
+
+/**
+ * Retrieves detailed protocol information for a specific blockchain network.
+ * 
+ * @param chainId - The numeric identifier of the blockchain network
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns Array of protocol details supported on the specified chain
+ * @example
+ * ```typescript
+ * const protocols = getProtocolInfoByChainId(1, 'api-key');
+ * // Returns array of protocol details for Ethereum mainnet
+ * ```
+ */
+export const getProtocolInfoByChainId = (
+  chainId: number,
+  theGraphApiKey: string
+): ProtocolDetails[] => {
+  try {
+    const protocolConfig = getAmmConfig(theGraphApiKey);
+    const supportedProtocols: SupportedProtocol[] = Object.keys(
+      protocolConfig
+    ) as SupportedProtocol[];
+
+    const protocolsForChain: ProtocolDetails[] = [];
+    supportedProtocols.forEach((protocolName) => {
+      const protocolData = protocolConfig[protocolName];
+      const chainName = chainIdToName(chainId);
+
+      if (chainName && protocolData && protocolData.subgraph[chainName as Chain]) {
+        protocolsForChain.push({
+          name: protocolName,
+          data: protocolData,
+        });
+      }
+    });
+
+    return protocolsForChain;
+  } catch (error) {
+    console.error("Error fetching protocol info:", error);
+    return [];
+  }
+}
+
+/**
+ * Gets a list of supported protocols for a specific blockchain network.
+ * 
+ * @param chainId - The numeric identifier of the blockchain network
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns Array of protocol names supported on the specified chain
+ * @example
+ * ```typescript
+ * const protocols = getProtocolsForChainId(1, 'api-key');
+ * // Returns ['Uniswap', 'Sushi', ...] for Ethereum mainnet
+ * ```
+ */
+export const getProtocolsForChainId = (
+  chainId: number,
+  theGraphApiKey: string
+): SupportedProtocol[] => {
+  try {
+    const protocolConfig = getAmmConfig(theGraphApiKey);
+    const supportedProtocols: SupportedProtocol[] = Object.keys(
+      protocolConfig
+    ) as SupportedProtocol[];
+
+    const protocolsForChain: ProtocolDetails[] = [];
+    supportedProtocols.forEach((protocolName) => {
+      const protocolData = protocolConfig[protocolName];
+      const chainName = chainIdToName(chainId);
+
+      if (chainName && protocolData && protocolData.subgraph[chainName as Chain]) {
+        protocolsForChain.push({
+          name: protocolName,
+          data: protocolData,
+        });
+      }
+    });
+
+    return protocolsForChain.map(({ name }) => name);
+  } catch (error) {
+    console.error("Error fetching protocol info:", error);
+    return [];
+  }
+}
+
+/**
+ * Retrieves protocol information for a specific protocol by its name.
+ * 
+ * @param protocolName - The name of the protocol to get information for
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns Protocol configuration and information
+ * @example
+ * ```typescript
+ * const info = getProtocolInfoByName('Uniswap', 'api-key');
+ * ```
+ */
+export const getProtocolInfoByName = (
+  protocolName: Protocol,
+  theGraphApiKey: string
+): ProtocolInfo | undefined => {
+  return getAmmConfig(theGraphApiKey)[protocolName];
+}
+
+/**
+ * Finds a protocol by its subgraph URL.
+ * 
+ * @param subgraphUrl - The subgraph URL to search for
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns The protocol name if found, undefined otherwise
+ * @example
+ * ```typescript
+ * const protocol = getProtocolBySubgraph('https://api.thegraph.com/...', 'api-key');
+ * ```
+ */
+export const getProtocolBySubgraph = (
+  subgraphUrl: string,
+  theGraphApiKey: string
+): SupportedProtocol | undefined => {
+  try {
+    const protocolConfig = getAmmConfig(theGraphApiKey);
+    const supportedProtocols: SupportedProtocol[] = Object.keys(
+      protocolConfig
+    ) as SupportedProtocol[];
+
+    const protocol = supportedProtocols.find((protocolName) => {
+      const protocolData = protocolConfig[protocolName];
+      if (!protocolData) return false;
+      const subgraphs = Object.values(protocolData.subgraph);
+      return subgraphs.includes(subgraphUrl);
+    });
+
+    return protocol;
+  } catch (error) {
+    console.error("Error fetching protocol info:", error);
+    return undefined;
+  }
+}
+
+/**
+ * Checks if a protocol is an Algebra protocol based on its subgraph URL.
+ * 
+ * @param subgraphUrl - The subgraph URL to check
+ * @param theGraphApiKey - The Graph API key for accessing protocol data
+ * @returns True if the protocol is an Algebra protocol, false otherwise
+ * @example
+ * ```typescript
+ * const isAlgebra = isAlgebraProtocolBySubgraph('https://api.thegraph.com/...', 'api-key');
+ * ```
+ */
+export function isAlgebraProtocolBySubgraph(subgraphUrl: string, theGraphApiKey: string): boolean {
+  const protocolConfig = getAmmConfig(theGraphApiKey);
+  const algebraSubgraphUrls = ALGEBRA_PROTOCOLS.flatMap((protocol: SupportedProtocol) =>
+    Object.values(protocolConfig[protocol]?.subgraph || {})
+  );
+  return algebraSubgraphUrls.includes(subgraphUrl);
+} 

package/src/const/api.ts

@@ -0,0 +1,27 @@
+/**
+ * API URLs for different environments and versions
+ */
+export const API_URLS = {
+  v1: {
+    production: 'https://s55qpiwei1.execute-api.us-east-1.amazonaws.com',
+    development: 'https://s55qpiwei1.execute-api.us-east-1.amazonaws.com', // Currently same as production
+  },
+  // Add future versions here
+  // v2: {
+  //   production: 'https://v2-prod.api.steer.finance',
+  //   development: 'https://v2-dev.api.steer.finance',
+  // },
+} as const;
+
+/**
+ * Get the API URL for a specific environment and version
+ * @param environment - The environment to get the URL for
+ * @param version - The API version to use (defaults to v1)
+ * @returns The API URL for the specified environment and version
+ */
+export function getApiUrl(
+  environment: 'production' | 'development', 
+  version: keyof typeof API_URLS = 'v1'
+): string {
+  return API_URLS[version][environment];
+} 

package/src/const/capabilities.ts

@@ -0,0 +1,115 @@
+import { Chain, ChainId } from './chain.js';
+import { getSubgraphUrlByChainId, steerSubgraphConfig } from './subgraph.js';
+import { isSingleAssetDepositSupported, networks, type NetworkConfig } from './network.js';
+import { getProtocolInfoByChainId, type ProtocolDetails } from './amm/utils/protocol.js';
+
+export type SupportedChainsFeature =
+  | 'subgraph'
+  | 'deployments'
+  | 'protocols'
+  | 'singleAssetDeposit';
+
+export type SupportedChainsInclude = {
+  subgraph?: boolean;
+  deployments?: boolean;
+  protocols?: boolean;
+  singleAssetDeposit?: boolean;
+};
+
+export type GetSupportedChainsOptions = {
+  theGraphApiKey?: string;
+  include?: SupportedChainsInclude;
+  filter?: {
+    feature?: SupportedChainsFeature;
+  };
+};
+
+export type SupportedChainFeatures = {
+  subgraph: boolean;
+  deployments: boolean;
+  protocols: boolean;
+  singleAssetDeposit: boolean;
+};
+
+export type SupportedChain = {
+  schemaVersion: 1;
+  chain: Chain;
+  chainId: number;
+  features: SupportedChainFeatures;
+  subgraphUrl?: string;
+  deployments?: NetworkConfig;
+  protocols?: ProtocolDetails[];
+};
+
+function getChainId(chain: Chain): number {
+  return ChainId[chain];
+}
+
+function defaultInclude(include?: SupportedChainsInclude): Required<SupportedChainsInclude> {
+  return {
+    subgraph: include?.subgraph ?? true,
+    deployments: include?.deployments ?? false,
+    protocols: include?.protocols ?? false,
+    singleAssetDeposit: include?.singleAssetDeposit ?? false,
+  };
+}
+
+export function getSupportedChains(options: GetSupportedChainsOptions = {}): SupportedChain[] {
+  const include = defaultInclude(options.include);
+
+  const chains: SupportedChain[] = Object.values(Chain)
+    .filter((chain) => Boolean(steerSubgraphConfig[chain]))
+    .map((chain) => {
+      const chainId = getChainId(chain);
+
+      const subgraphUrl = include.subgraph ? getSubgraphUrlByChainId(chainId) : undefined;
+      const deployments = include.deployments ? networks[chain] : undefined;
+
+      const protocols = include.protocols
+        ? getProtocolInfoByChainId(chainId, options.theGraphApiKey ?? '')
+        : undefined;
+
+      const singleAssetDeposit = include.singleAssetDeposit
+        ? isSingleAssetDepositSupported(chainId)
+        : false;
+
+      const features: SupportedChainFeatures = {
+        subgraph: Boolean(subgraphUrl),
+        deployments: Boolean(deployments),
+        protocols: Boolean(protocols && protocols.length > 0),
+        singleAssetDeposit,
+      };
+
+      const supportedChain: SupportedChain = {
+        schemaVersion: 1 as const,
+        chain,
+        chainId,
+        features,
+      };
+
+      if (include.subgraph) supportedChain.subgraphUrl = subgraphUrl;
+      if (include.deployments) supportedChain.deployments = deployments;
+      if (include.protocols) supportedChain.protocols = protocols;
+
+      return supportedChain;
+    });
+
+  const featureFilter = options.filter?.feature;
+  if (!featureFilter) return chains;
+
+  return chains.filter((c) => c.features[featureFilter]);
+}
+
+export function getSupportedChainIds(options: GetSupportedChainsOptions = {}): number[] {
+  return getSupportedChains(options).map((c) => c.chainId);
+}
+
+export function getSupportedChainByChainId(
+  chainId: number,
+  options: Omit<GetSupportedChainsOptions, 'filter'> = {}
+): SupportedChain | undefined {
+  const chainName = Object.values(Chain).find((chain) => getChainId(chain) === chainId);
+  if (!chainName) return undefined;
+
+  return getSupportedChains({ ...options }).find((c) => c.chainId === chainId);
+}