@strkfarm/sdk 2.0.0-dev.9 → 2.0.0-staging.2

package/src/interfaces/common.tsx

@@ -3,258 +3,398 @@ import { BlockIdentifier, BlockTag, constants, RpcProvider } from "starknet";
 import React, { ReactNode } from "react";
 
 export enum RiskType {
-  MARKET_RISK = "Market Risk",
-  // if non-correalted pairs, this is 3 (STRK/USDC)
-  // if highly correalted pairs, this is 1 (e.g. xSTRK/STRK)
-  // if correalted pairs, this is 2 (e.g. BTC/SOL)
-  // If there is added leverage on top, can go till 5
-  IMPERMANENT_LOSS = "Impermanent Loss Risk",
-  LIQUIDATION_RISK = "Liquidation Risk",
-  LOW_LIQUIDITY_RISK = "Low Liquidity Risk",
-  SMART_CONTRACT_RISK = "Smart Contract Risk",
-  ORACLE_RISK = "Oracle Risk",
-  TECHNICAL_RISK = "Technical Risk",
-  COUNTERPARTY_RISK = "Counterparty Risk", // e.g. bad debt
-  DEPEG_RISK = "Depeg Risk" // e.g. USDC depeg
+    MARKET_RISK = "Market Risk",
+    // if non-correalted pairs, this is 3 (STRK/USDC)
+    // if highly correalted pairs, this is 1 (e.g. xSTRK/STRK)
+    // if correalted pairs, this is 2 (e.g. BTC/SOL)
+    // If there is added leverage on top, can go till 5
+    IMPERMANENT_LOSS = "Impermanent Loss Risk",
+    LIQUIDATION_RISK = "Liquidation Risk",
+    LOW_LIQUIDITY_RISK = "Low Liquidity Risk",
+    SMART_CONTRACT_RISK = "Smart Contract Risk",
+    ORACLE_RISK = "Oracle Risk",
+    TECHNICAL_RISK = "Technical Risk",
+    COUNTERPARTY_RISK = "Counterparty Risk", // e.g. bad debt
+    DEPEG_RISK = "Depeg Risk" // e.g. USDC depeg
 }
 
 export interface RiskFactor {
-  type: RiskType;
-  value: number; // 0 to 5
-  weight: number; // 0 to 100
-  reason?: string; // optional reason for the risk factor
+    type: RiskType;
+    value: number; // 0 to 5
+    weight: number; // 0 to 100
+    reason?: string; // optional reason for the risk factor
 }
 
 export interface TokenInfo {
-  name: string;
-  symbol: string;
-  address: ContractAddr;
-  decimals: number;
-  logo: string;
-  coingeckId?: string;
-  displayDecimals: number;
-  priceProxySymbol?: string; // for tokens like illiquid tokens, we use a proxy symbol to get the price
-  priceCheckAmount?: number; // for tokens like BTC, doing 1BTC price check may not be ideal, esp on illiquid netwrks like sn
+    name: string;
+    symbol: string;
+    address: ContractAddr;
+    decimals: number;
+    logo: string;
+    coingeckId?: string;
+    displayDecimals: number;
+    priceProxySymbol?: string; // for tokens like illiquid tokens, we use a proxy symbol to get the price
+    priceCheckAmount?: number; // for tokens like BTC, doing 1BTC price check may not be ideal, esp on illiquid netwrks like sn
 }
 
 export enum Network {
-  mainnet = "mainnet",
-  sepolia = "sepolia",
-  devnet = "devnet"
+    mainnet = "mainnet",
+    sepolia = "sepolia",
+    devnet = "devnet"
 }
 
 export interface IConfig {
-  provider: RpcProvider;
-  network: Network;
-  stage: "production" | "staging";
-  heartbeatUrl?: string;
+    provider: RpcProvider;
+    network: Network;
+    stage: "production" | "staging";
+    heartbeatUrl?: string;
 }
 
 export interface IProtocol {
-  name: string;
-  logo: string;
+    name: string;
+    logo: string;
+}
+
+// Strategy-level enums
+export enum StrategyCategory {
+    ALL = "all",
+    BTC = "btc",
+    META_VAULTS = "meta-vaults"
+}
+
+// Security metadata enums
+export enum AuditStatus {
+    AUDITED = "Audited",
+    NOT_AUDITED = "Not Audited"
+}
+
+export enum SourceCodeType {
+    OPEN_SOURCE = "Open Source",
+    CLOSED_SOURCE = "Closed Source"
+}
+
+export enum AccessControlType {
+    MULTISIG_ACCOUNT = "Multisig Account",
+    STANDARD_ACCOUNT = "Standard Account"
+}
+
+export enum InstantWithdrawalVault {
+    YES = "Yes",
+    NO = "No"
+}
+
+// Security metadata interfaces
+export interface SourceCodeInfo {
+    type: SourceCodeType;
+    contractLink: string;
+}
+
+export interface AccessControlInfo {
+    type: AccessControlType;
+    addresses: ContractAddr[];
+    timeLock: string;
+}
+
+export interface SecurityMetadata {
+    auditStatus: AuditStatus;
+    sourceCode: SourceCodeInfo;
+    accessControl: AccessControlInfo;
+}
+
+// Redemption metadata interfaces
+export interface RedemptionExpectedTime {
+    upto1M: string;
+    upto10M: string;
+    above10M: string;
+}
+
+export interface RedemptionInfo {
+    instantWithdrawalVault: InstantWithdrawalVault;
+    expectedRedemptionTime?: RedemptionExpectedTime;
 }
 
 export enum FlowChartColors {
-  Green = "purple",
-  Blue = "#35484f",
-  Purple = "#6e53dc"
+    Green = "purple",
+    Blue = "#35484f",
+    Purple = "#6e53dc"
 }
 
 export interface FAQ {
-  question: string | React.ReactNode;
-  answer: string | React.ReactNode;
+    question: string | React.ReactNode;
+    answer: string | React.ReactNode;
+}
+
+/**
+ * Strategy Live Status - indicates the current state of a strategy
+ */
+export enum StrategyLiveStatus {
+    ACTIVE = "Active",
+    NEW = "New",
+    COMING_SOON = "Coming Soon",
+    RETIRED = "Retired",
+    HOT = "Hot & New 🔥"
+}
+
+/**
+ * Strategy Tags - used for filtering and categorization
+ */
+export enum StrategyTag {
+    EKUBO = "Ekubo",
+    EVERGREEN = "Evergreen",
+    HYPER_LST = "Hyper-LST",
+    VESU = "Vesu",
+    SENSEI = "Sensei",
+    ENDUR = "Endur",
+    BTC = "BTC"
+}
+
+/**
+ * Strategy Alert - informational or warning messages for users
+ */
+export interface StrategyAlert {
+    type: "warning" | "info";
+    text: string | React.ReactNode;
+    tab: "all" | "deposit" | "withdraw";
+}
+
+/**
+ * Strategy Settings - configuration and UI settings for strategies
+ */
+export interface StrategySettings {
+    maxTVL?: Web3Number;
+    liveStatus?: StrategyLiveStatus;
+    isPaused?: boolean;
+    isInMaintenance?: boolean;
+    isAudited: boolean;
+    isInstantWithdrawal?: boolean;
+    hideHarvestInfo?: boolean;
+    is_promoted?: boolean;
+    isTransactionHistDisabled?: boolean;
+    quoteToken: TokenInfo;
+    hideNetEarnings?: boolean;
+    showWithdrawalWarningModal?: boolean;
+    alerts?: StrategyAlert[];
+    tags?: StrategyTag[];
 }
 
 /**
  * @property risk.riskFactor.factor - The risk factors that are considered for the strategy.
  * @property risk.riskFactor.factor - The value of the risk factor from 0 to 10, 0 being the lowest and 10 being the highest.
+ * @property security - Security-related metadata including audit status, source code information, and access control details.
+ * @property redemptionInfo - Redemption information including instant withdrawal availability and expected redemption times.
  */
 export interface IStrategyMetadata<T> {
-  name: string;
-  description: string | React.ReactNode;
-  address: ContractAddr;
-  launchBlock: number;
-  type: "ERC4626" | "ERC721" | "Other";
-  depositTokens: TokenInfo[];
-  protocols: IProtocol[];
-  auditUrl?: string;
-  maxTVL: Web3Number;
-  risk: {
-    riskFactor: RiskFactor[];
-    netRisk: number;
-    notARisks: RiskType[];
-  };
-  apyMethodology?: string;
-  additionalInfo: T;
-  contractDetails: {
-    address: ContractAddr;
+    id: string;
     name: string;
-    sourceCodeUrl?: string;
-  }[],
-  faqs: FAQ[];
-  points?: {multiplier: number, logo: string, toolTip?: string}[];
-  docs?: string;
-  investmentSteps: string[];
-  curator?: { name: string, logo: string },
-  isPreview?: boolean
+    description: string | React.ReactNode;
+    address: ContractAddr;
+    launchBlock: number;
+    type: "ERC4626" | "ERC721" | "Other";
+    depositTokens: TokenInfo[];
+    protocols: IProtocol[];
+    auditUrl?: string;
+    risk: {
+        riskFactor: RiskFactor[];
+        netRisk: number;
+        notARisks: RiskType[];
+    };
+    apyMethodology?: string;
+    additionalInfo: T;
+    contractDetails: {
+        address: ContractAddr;
+        name: string;
+        sourceCodeUrl?: string;
+    }[];
+    faqs: FAQ[];
+    points?: { multiplier: number; logo: string; toolTip?: string }[];
+    docs?: string;
+    investmentSteps: string[];
+    curator?: { name: string; logo: string };
+    isPreview?: boolean;
+    category?: StrategyCategory;
+    tags?: StrategyTag[];
+    security?: SecurityMetadata;
+    redemptionInfo?: RedemptionInfo;
+    settings?: StrategySettings;
+    // Legacy field for multi-step strategies (deprecated, use investmentFlows instead)
+    actions?: Array<{
+        name?: string;
+        pool?: {
+            protocol?: { name: string; logo: string };
+            pool?: { name: string; logos?: string[] };
+            apr?: number;
+            borrow?: { apr?: number };
+        };
+        amount?: string | number;
+        isDeposit?: boolean;
+    }>;
 }
 
 export interface IInvestmentFlow {
-  id?: string; // used to link flows
-  title: string;
-  subItems: { key: string; value: string }[];
-  linkedFlows: IInvestmentFlow[];
-  style?: any;
+    id?: string; // used to link flows
+    title: string;
+    subItems: { key: string; value: string }[];
+    linkedFlows: IInvestmentFlow[];
+    style?: any;
 }
 
 export function getMainnetConfig(
-  rpcUrl: string = 'https://starknet-mainnet.public.blastapi.io',
-  blockIdentifier: BlockIdentifier = BlockTag.LATEST
-  // specVersion = constants.SupportedRpcVersion.v0_8_1
+    rpcUrl: string = "https://starknet-mainnet.public.blastapi.io",
+    blockIdentifier: BlockIdentifier = BlockTag.LATEST
+    // specVersion = constants.SupportedRpcVersion.v0_8_1
 ): IConfig {
-  return {
-    provider: new RpcProvider({
-      nodeUrl: rpcUrl,
-      blockIdentifier: blockIdentifier,
-      // specVersion
-    }),
-    stage: "production",
-    network: Network.mainnet
-  };
+    return {
+        provider: new RpcProvider({
+            nodeUrl: rpcUrl,
+            blockIdentifier: blockIdentifier
+            // specVersion
+        }),
+        stage: "production",
+        network: Network.mainnet
+    };
 }
 
 export const getRiskExplaination = (riskType: RiskType) => {
-  switch (riskType) {
-    case RiskType.MARKET_RISK:
-      return "The risk of the market moving against the position.";
-    case RiskType.IMPERMANENT_LOSS:
-      return "The temporary loss of value experienced by liquidity providers in AMMs when asset prices diverge compared to simply holding them.";
-    case RiskType.LIQUIDATION_RISK:
-      return "The risk of losing funds due to the position being liquidated.";
-    case RiskType.LOW_LIQUIDITY_RISK:
-      return "The risk of low liquidity in the pool, which can lead to high slippages or reduced in-abilities to quickly exit the position.";
-    case RiskType.ORACLE_RISK:
-      return "The risk of the oracle being manipulated or incorrect.";
-    case RiskType.SMART_CONTRACT_RISK:
-      return "The risk of the smart contract being vulnerable to attacks.";
-    case RiskType.TECHNICAL_RISK:
-      return "The risk of technical issues e.g. backend failure.";
-    case RiskType.COUNTERPARTY_RISK:
-      return "The risk of the counterparty defaulting e.g. bad debt on lending platforms.";
-    case RiskType.DEPEG_RISK:
-      return "The risk of a token losing its peg to the underlying asset, leading to potential losses for holders.";
-  }
+    switch (riskType) {
+        case RiskType.MARKET_RISK:
+            return "The risk of the market moving against the position.";
+        case RiskType.IMPERMANENT_LOSS:
+            return "The temporary loss of value experienced by liquidity providers in AMMs when asset prices diverge compared to simply holding them.";
+        case RiskType.LIQUIDATION_RISK:
+            return "The risk of losing funds due to the position being liquidated.";
+        case RiskType.LOW_LIQUIDITY_RISK:
+            return "The risk of low liquidity in the pool, which can lead to high slippages or reduced in-abilities to quickly exit the position.";
+        case RiskType.ORACLE_RISK:
+            return "The risk of the oracle being manipulated or incorrect.";
+        case RiskType.SMART_CONTRACT_RISK:
+            return "The risk of the smart contract being vulnerable to attacks.";
+        case RiskType.TECHNICAL_RISK:
+            return "The risk of technical issues e.g. backend failure.";
+        case RiskType.COUNTERPARTY_RISK:
+            return "The risk of the counterparty defaulting e.g. bad debt on lending platforms.";
+        case RiskType.DEPEG_RISK:
+            return "The risk of a token losing its peg to the underlying asset, leading to potential losses for holders.";
+    }
 };
 
 export const getRiskColor = (risk: RiskFactor) => {
-  const value = risk.value;
-  if (value <= 2) return "light_green_2";
-  if (value < 3) return "yellow";
-  return "red";
+    const value = risk.value;
+    if (value <= 2) return "light_green_2";
+    if (value < 3) return "yellow";
+    return "red";
 };
 
 export const getNoRiskTags = (risks: RiskFactor[]) => {
-  const noRisks1 = risks
-    .filter((risk) => risk.value === 0)
-    .map((risk) => risk.type);
+    const noRisks1 = risks
+        .filter((risk) => risk.value === 0)
+        .map((risk) => risk.type);
 
-  // const risks not present
-  const noRisks2 = Object.values(RiskType).filter(
-    (risk) => !risks.map((risk) => risk.type).includes(risk)
-  );
+    // const risks not present
+    const noRisks2 = Object.values(RiskType).filter(
+        (risk) => !risks.map((risk) => risk.type).includes(risk)
+    );
 
-  const mergedUnique = [...new Set([...noRisks1, ...noRisks2])];
+    const mergedUnique = [...new Set([...noRisks1, ...noRisks2])];
 
-  // add `No` to the start of each risk
-  return mergedUnique
+    // add `No` to the start of each risk
+    return mergedUnique;
 };
 
 interface HighlightLink {
-  highlight: string;
-  link: string;
+    highlight: string;
+    link: string;
 }
 
 export function highlightTextWithLinks(
-  put: string,
-  highlights: HighlightLink[],
+    put: string,
+    highlights: HighlightLink[]
 ): ReactNode {
-  // Escape RegExp special characters in highlight strings
-  const escapeRegExp = (text: string) =>
-    text.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
-
-  // Create a single regex for all highlight terms
-  const pattern = new RegExp(
-    `(${highlights.map(m => escapeRegExp(m.highlight)).join('|')})`,
-    'gi'
-  );
-
-  const parts = put.split(pattern);
-
-  return (
-    <>
-      {parts.map((part, i) => {
-        const match = highlights.find(m => m.highlight.toLowerCase() === part.toLowerCase());
-        return match ? (
-          <a key={i} href={match.link} target="_blank" style={{ color: 'var(--chakra-colors-white)', background: 'var(--chakra-colors-highlight)' }}>
-            {part}
-          </a>
-        ) : (
-          <span key={i}>{part}</span>
-        );
-      })}
-    </>
-  );
+    // Escape RegExp special characters in highlight strings
+    const escapeRegExp = (text: string) =>
+        text.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+
+    // Create a single regex for all highlight terms
+    const pattern = new RegExp(
+        `(${highlights.map((m) => escapeRegExp(m.highlight)).join("|")})`,
+        "gi"
+    );
+
+    const parts = put.split(pattern);
+
+    return (
+        <>
+            {parts.map((part, i) => {
+                const match = highlights.find(
+                    (m) => m.highlight.toLowerCase() === part.toLowerCase()
+                );
+                return match ? (
+                    <a
+                        key={i}
+                        href={match.link}
+                        target="_blank"
+                        style={{
+                            color: "var(--chakra-colors-white)",
+                            background: "var(--chakra-colors-highlight)"
+                        }}
+                    >
+                        {part}
+                    </a>
+                ) : (
+                    <span key={i}>{part}</span>
+                );
+            })}
+        </>
+    );
 }
 
 export interface VaultPosition {
-  amount: Web3Number,
-  usdValue: number,
-  token: TokenInfo,
-  remarks: string,
-  protocol: IProtocol
+    amount: Web3Number;
+    usdValue: number;
+    token: TokenInfo;
+    remarks: string;
 }
 
-const VesuProtocol: IProtocol = {
-  name: "Vesu",
-  logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"
-};
+export interface AmountInfo {
+    amount: Web3Number;
+    usdValue: number;
+    tokenInfo: TokenInfo;
+}
 
-const AvnuProtocol: IProtocol = {
-  name: "Avnu",
-  logo: "https://static-assets-8zct.onrender.com/integrations/avnu/logo.png"
+export interface AmountsInfo {
+    usdValue: number;
+    amounts: AmountInfo[];
 }
 
-const EndurProtocol: IProtocol = {
-  name: "Endur",
-  logo: "http://endur.fi/logo.png"
+/**
+ * Strategy capabilities interface
+ * Describes what optional methods a strategy instance supports
+ */
+export interface StrategyCapabilities {
+    hasMatchInputAmounts: boolean;
+    hasNetAPY: boolean;
+    hasGetInvestmentFlows: boolean;
+    hasGetPendingRewards: boolean;
+    hasHarvest: boolean;
+    hasRebalance: boolean;
 }
 
-const ExtendedProtocol: IProtocol = {
-  name: "Extended",
-  logo: "https://static-assets-8zct.onrender.com/integrations/extended/extended.svg"
+const VesuProtocol: IProtocol = {
+    name: "Vesu",
+    logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"
 };
 
-const EkuboProtocol: IProtocol = {
-  name: "Ekubo",
-  logo: "https://app.ekubo.org/favicon.ico"
+const EndurProtocol: IProtocol = {
+    name: "Endur",
+    logo: "http://endur.fi/logo.png"
 };
 
-const NoneProtocol: IProtocol = {
-  name: "-",
-  logo: ""
-}
+const ExtendedProtocol: IProtocol = {
+    name: "Extended",
+    logo: "https://static-assets-8zct.onrender.com/integrations/extended/extended.svg"
+};
 
-const VaultProtocol: IProtocol = {
-  name: "Vault",
-  logo: ""
-}
 export const Protocols = {
-  NONE: NoneProtocol,
-  VESU: VesuProtocol,
-  ENDUR: EndurProtocol,
-  EXTENDED: ExtendedProtocol,
-  EKUBO: EkuboProtocol,
-  AVNU: AvnuProtocol,
-  VAULT: VaultProtocol
-}
+    VESU: VesuProtocol,
+    ENDUR: EndurProtocol,
+    EXTENDED: ExtendedProtocol
+};

package/src/modules/apollo-client-config.ts

@@ -0,0 +1,28 @@
+import { ApolloClient, InMemoryCache } from '@apollo/client';
+import { IConfig } from '@/interfaces';
+
+/**
+ * Creates an Apollo Client instance configured for the appropriate environment
+ * @param config - The application config containing network and stage information
+ * @returns Configured Apollo Client instance
+ */
+export function createApolloClient(config: IConfig) {
+  // Determine the URI based on the environment
+  const uri = config.stage === 'production' 
+    ? 'https://api.troves.fi/' 
+    : 'http://localhost:4000';
+
+  return new ApolloClient({
+    uri,
+    cache: new InMemoryCache(),
+  });
+}
+
+// Default client for backward compatibility
+const apolloClient = new ApolloClient({
+  uri: 'https://api.troves.fi/',
+  cache: new InMemoryCache(),
+});
+
+export default apolloClient;
+

package/src/modules/avnu.ts

@@ -37,7 +37,7 @@ export class AvnuWrapper {
     excludeSources = ['Haiko(Solvers)']
   ): Promise<Quote> {
     const MAX_RETRY = 5;
-    logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
+    // logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
     const params: any = {
       sellTokenAddress: fromToken,
       buyTokenAddress: toToken,
@@ -100,9 +100,9 @@ export class AvnuWrapper {
     // swapInfo as expected by the strategy
     // fallback, max 1% slippage
     const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo: SwapInfo = {
       token_from_address: quote.sellTokenAddress,
       token_from_amount: uint256.bnToUint256(quote.sellAmount),
@@ -135,17 +135,4 @@ export class AvnuWrapper {
       routes: [],
     };
   }
-
-
-  async getSwapCallData(
-    quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>,
-    taker: string,
-  ) {
-    const calldata = await fetchBuildExecuteTransaction(quote.quoteId, taker, undefined, false);
-    const result = calldata.calls.map((call: Call) => {
-      const data = call.calldata as string[];
-      return data.map(x => BigInt(x));
-    });
-    return result;
-  }
 }