@steerprotocol/sdk 1.26.0 → 1.28.0

package/src/const/protocol.ts

@@ -0,0 +1,229 @@
+import { AMMType } from '../base/vault/single-asset/types.js';
+import { SupportedProtocol } from '../types.js';
+import { Protocol } from './chain.js';
+
+/**
+ * Enum representing supported staking protocols
+ */
+export enum StakingProtocol {
+  Forge = 'Forge',
+  Kinetix = 'Kinetix',
+  Uniswap = 'Uniswap',
+  SushiSwap = 'SushiSwap',
+  QuickSwapV3 = 'QuickSwapV3',
+  ArthSwap = 'ArthSwap',
+  arthswap = 'arthswap',
+  Swapsicle = 'Swapsicle',
+  Spark = 'Spark',
+  Spark32 = 'Spark32',
+}
+
+/**
+ * Checks if a given string is a valid StakingProtocol enum value.
+ *
+ * @param protocol - The protocol string to validate
+ * @returns True if the protocol is a valid StakingProtocol, false otherwise
+ * @example
+ * ```typescript
+ * if (isValidStakingProtocol('Uniswap')) {
+ *   // Handle valid protocol
+ * }
+ * ```
+ */
+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);
+}
+
+/**
+ * Normalizes a protocol string to its corresponding StakingProtocol enum value.
+ *
+ * @param protocol - The protocol string to normalize
+ * @returns The normalized StakingProtocol enum value
+ * @throws Error if the protocol string is invalid
+ * @example
+ * ```typescript
+ * const protocol = normalizeProtocol('uniswap');
+ * // Returns: StakingProtocol.Uniswap
+ * ```
+ */
+export function normalizeProtocol(protocol: string): StakingProtocol {
+  const normalizedProtocol = protocol.charAt(0).toUpperCase() + protocol.slice(1).toLowerCase();
+  if (!isValidStakingProtocol(normalizedProtocol)) {
+    throw new Error(`Invalid protocol: ${protocol}`);
+  }
+  return normalizedProtocol as StakingProtocol;
+}
+
+/**
+ * List of protocols that implement the Algebra interface
+ */
+
+
+export const ALGEBRA_PROTOCOLS = [
+  Protocol.QuickSwap,
+  Protocol.Wasabee,
+  Protocol.Beam,
+  Protocol.QuickSwapIntegral,
+  Protocol.SilverSwap,
+  Protocol.Ocelex,
+  Protocol.Henjin,
+  Protocol.Camelot,
+  Protocol.Ocelex,
+  Protocol.Lynex,
+  Protocol.Thena,
+  Protocol.Hercules,
+  Protocol.QuickSwapAlgebra,
+  Protocol.Kim,
+  Protocol.Swapsicle,
+  Protocol.Fenix,
+  Protocol.StellaSwap,
+  Protocol.Glyph,
+  Protocol.KatanaIntegral,
+  Protocol.Blackhole,
+  Protocol.Nest,
+  Protocol.Cypher,
+];
+
+export const SHADOW_PROTOCOLS = [Protocol.Shadow, Protocol.MachineX];
+
+/**
+ * List of protocols that implement directional Algebra interface
+ */
+export const DIRECTIONAL_ALGEBRA_PROTOCOLS = [Protocol.Camelot, Protocol.Hercules];
+
+/**
+ * List of protocols that implement the PoolShark interface
+ */
+export const POOLSHARK_PROTOCOLS = [Protocol.PoolShark];
+
+/**
+ * List of protocols that implement the Algebra Integral interface
+ */
+export const ALGEBRA_INTEGRAL_PROTOCOLS = [
+  Protocol.Kim,
+  Protocol.Wasabee,
+  Protocol.Swapsicle,
+  Protocol.QuickSwapIntegral,
+  Protocol.Fenix,
+  Protocol.Henjin,
+  Protocol.SilverSwap,
+  Protocol.Beam,
+  Protocol.Glyph,
+  Protocol.KatanaIntegral,
+  Protocol.Blackhole,
+  Protocol.Nest,
+  Protocol.Cypher,
+];
+
+export const AERODROME_PROTOCOLS = [Protocol.Aerodrome, Protocol.AerodromeV2, Protocol.Cypher];
+
+export const ALGEBRA_INTEGRAL_V_2_0_PROTOCOLS = [
+  Protocol.QuickSwapIntegral,
+  Protocol.Wasabee,
+  Protocol.KatanaIntegral,
+  Protocol.Blackhole,
+  Protocol.Cypher,
+]
+
+/**
+ * List of protocols that implement the Thick interface
+ */
+const THICK_PROTOCOLS = [Protocol.ThickV2];
+
+/**
+ * Checks if a protocol implements the Algebra interface.
+ *
+ * @param protocol - The protocol to check
+ * @returns True if the protocol implements Algebra, false otherwise
+ */
+export const isAlgebraProtocol = (protocol: SupportedProtocol) => {
+  return ALGEBRA_PROTOCOLS.includes(protocol);
+};
+
+
+/**
+ * Checks if a protocol implements the Shadow interface.
+ *
+ * @param protocol - The protocol to check
+ * @returns True if the protocol implements Shadow, false otherwise
+ */
+export const isShadowProtocol = (protocol: SupportedProtocol) => {
+  return SHADOW_PROTOCOLS.includes(protocol);
+};
+
+/**
+ * Checks if a protocol implements the ThickV2 interface.
+ *
+ * @param protocol - The protocol to check
+ * @returns True if the protocol implements ThickV2, false otherwise
+ */
+export const isThickV2Protocol = (protocol: SupportedProtocol) => {
+  return THICK_PROTOCOLS.includes(protocol);
+};
+
+/**
+ * Checks if a protocol implements the Algebra Direction interface.
+ *
+ * @param protocol - The protocol to check
+ * @returns True if the protocol implements Algebra Direction, false otherwise
+ */
+export const isAlgebraDirectionProtocol = (protocol: SupportedProtocol) => {
+  return DIRECTIONAL_ALGEBRA_PROTOCOLS.includes(protocol);
+};
+
+/**
+ * Checks if a protocol implements the Algebra Integral interface.
+ *
+ * @param protocol - The protocol to check
+ * @returns True if the protocol implements Algebra Integral, false otherwise
+ */
+export const isAlgebraIntegralProtocol = (protocol: SupportedProtocol) => {
+  return ALGEBRA_INTEGRAL_PROTOCOLS.includes(protocol);
+};
+
+
+/**
+ * Checks if a protocol implements the PoolShark interface.
+ *
+ * @param protocol - The protocol to check
+ * @returns True if the protocol implements PoolShark, false otherwise
+ */
+export const isPoolSharkProtocol = (protocol: SupportedProtocol) => {
+  return POOLSHARK_PROTOCOLS.includes(protocol);
+};
+
+
+export const isAerodromeVault = (protocol: SupportedProtocol): boolean => {
+    return AERODROME_PROTOCOLS.includes(protocol);
+}
+
+export const isAlgebraIntegralV2Protocol = (protocol: SupportedProtocol): boolean => {
+  return ALGEBRA_INTEGRAL_V_2_0_PROTOCOLS.includes(protocol);
+}
+
+export const getProtcolTypeByAmmType = (ammType: AMMType): Protocol => {
+
+  if (ammType === AMMType.Algebra) {
+    return Protocol.QuickSwap
+  }
+
+  if (ammType === AMMType.AlgebraDirectional) {
+    return Protocol.Camelot
+  }
+
+  if (ammType === AMMType.AlgebraIntegral) {
+    return Protocol.QuickSwapIntegral
+  }
+
+  if (ammType === AMMType.UniswapV3) {
+    return Protocol.Uniswap
+  }
+
+  if (ammType === AMMType.Aerodrome) {
+    return Protocol.Aerodrome
+  }
+
+  throw Error('Protocol type not found')
+}