@strkfarm/sdk 2.0.0-staging.7 → 2.0.0-staging.71

package/src/interfaces/common.tsx

@@ -25,6 +25,8 @@ export interface RiskFactor {
   reason?: string; // optional reason for the risk factor
 }
 
+export type PriceMethod = 'AvnuApi' | 'Coinbase' | 'Coinmarketcap' | 'Ekubo' | 'Avnu';
+
 export interface TokenInfo {
   name: string;
   symbol: string;
@@ -35,6 +37,8 @@ export interface TokenInfo {
   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
+  priceMethod?: PriceMethod; // preferred price source; tried first, then falls back to other methods
+  dontPrice?: boolean; // a flag that skips pricer to check these tokens. 
 }
 
 export enum Network {
@@ -55,25 +59,24 @@ export interface IProtocol {
   logo: string;
 }
 
-// Strategy-level enums
-export enum StrategyCategory {
-  ALL = "all",
-  BTC = "btc",
-  META_VAULTS = "meta-vaults",
+export interface ICurator {
+  name: string;
+  logo: string;
 }
 
 export enum StrategyTag {
-  EKUBO = "Ekubo",
-  EVERGREEN = "Evergreen",
-  HYPER_LST = "Hyper-LST",
-  VESU = "Vesu",
-  SENSEI = "Sensei",
-  ENDUR = "Endur",
-    BTC = "BTC"
+  META_VAULT = "Meta Vaults",
+  LEVERED = "Maxx",
+  AUTOMATED_LP = "Ekubo",
+  BTC = "BTC"
 }
 
 export enum VaultType {
-  FARMING = "farming"
+  LOOPING = "Looping",
+  META_VAULT = "Meta Vault",
+  DELTA_NEUTRAL = "Delta Neutral",
+  AUTOMATED_LP = "Automated LP",
+  TVA = "Troves Value Averaging",
 }
 
 // Security metadata enums
@@ -90,6 +93,7 @@ export enum SourceCodeType {
 export enum AccessControlType {
   MULTISIG_ACCOUNT = "Multisig Account",
   STANDARD_ACCOUNT = "Standard Account",
+  ROLE_BASED_ACCESS = "Role Based Access",
 }
 
 export enum InstantWithdrawalVault {
@@ -106,7 +110,7 @@ export interface SourceCodeInfo {
 export interface AccessControlInfo {
   type: AccessControlType;
   addresses: ContractAddr[];
-  timeLock: string;
+  timeLock?: string;
 }
 
 export interface SecurityMetadata {
@@ -115,16 +119,13 @@ export interface SecurityMetadata {
   accessControl: AccessControlInfo;
 }
 
-// Redemption metadata interfaces
-export interface RedemptionExpectedTime {
-  upto1M: string;
-  upto10M: string;
-  above10M: string;
-}
-
 export interface RedemptionInfo {
   instantWithdrawalVault: InstantWithdrawalVault;
-  expectedRedemptionTime?: RedemptionExpectedTime;
+  redemptionsInfo: {
+    title: string; // e.g. Upto $1M
+    description: string; // e.g. "1-2 hours"
+  }[],
+  alerts: StrategyAlert[];
 }
 
 export enum FlowChartColors {
@@ -142,7 +143,8 @@ export enum StrategyLiveStatus {
     ACTIVE = "Active",
     NEW = "New",
     COMING_SOON = "Coming Soon",
-    RETIRED = "Retired",
+    DEPRECATED = "Deprecated", // active but not recommended
+    RETIRED = "Retired", // not active anymore
     HOT = "Hot & New 🔥"
 }
 
@@ -153,7 +155,6 @@ export interface StrategyAlert {
 }
 
 export interface StrategySettings {
-    maxTVL?: Web3Number;
     liveStatus?: StrategyLiveStatus;
     isPaused?: boolean;
     isInMaintenance?: boolean;
@@ -169,6 +170,17 @@ export interface StrategySettings {
     tags?: StrategyTag[];
 }
 
+export interface StrategyApyHistoryUIConfig {
+  // Defaults to true in UI if omitted.
+  showApyHistory?: boolean;
+  // Optional message shown when APY history is hidden.
+  noApyHistoryMessage?: string;
+}
+
+export interface FeeBps {
+  performanceFeeBps: number;
+}
+
 /**
  * @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.
@@ -179,6 +191,19 @@ export interface IStrategyMetadata<T> {
   id: string;
   name: string;
   description: string | React.ReactNode;
+  /**
+   * Optional UI sort priority. Higher shows earlier.
+   * Intended for pinning flagship parent vaults (e.g. BTC above STRK).
+   */
+  priority?: number;
+  /**
+   * Optional UI config for the variant intro popup (strategy page).
+   * Should be identical across strategies that share the same `parentId`.
+   */
+  variantIntro?: {
+    title: string;
+    description: string;
+  };
   address: ContractAddr;
   launchBlock: number;
   type: "ERC4626" | "ERC721" | "Other";
@@ -195,6 +220,8 @@ export interface IStrategyMetadata<T> {
     notARisks: RiskType[];
   };
   apyMethodology?: string;
+  realizedApyMethodology?: string;
+  feeBps?: FeeBps;
   additionalInfo: T;
   contractDetails: {
     address: ContractAddr;
@@ -205,13 +232,20 @@ export interface IStrategyMetadata<T> {
   points?: {multiplier: number, logo: string, toolTip?: string}[];
   docs?: string;
   investmentSteps: string[];
-  curator?: { name: string, logo: string },
+  curator?: ICurator,
   isPreview?: boolean;
-  category: StrategyCategory;
   tags?: StrategyTag[];
   security: SecurityMetadata;
   redemptionInfo: RedemptionInfo;
+  usualTimeToEarnings: null | string; // e.g. "2 weeks" // some strats grow like step functions
+  usualTimeToEarningsDescription: null | string; // e.g. "LSTs price on DEX goes up roughly every 2 weeks"
+  discontinuationInfo?: {
+    date?: Date;
+    reason?: React.ReactNode | string;
+    info?: React.ReactNode | string;
+  };
   settings?: StrategySettings;
+  apyHistoryUIConfig?: StrategyApyHistoryUIConfig;
     // Legacy field for multi-step strategies (deprecated, use investmentFlows instead)
     actions?: Array<{
         name?: string;
@@ -224,6 +258,8 @@ export interface IStrategyMetadata<T> {
         amount?: string | number;
         isDeposit?: boolean;
     }>;
+  parentId?: string;
+  parentName?: string;
 }
 
 export interface IInvestmentFlow {
@@ -250,6 +286,23 @@ export function getMainnetConfig(
   };
 }
 
+export const getStrategyTagDesciption = (tag: StrategyTag): string => {
+  switch (tag) {
+    case StrategyTag.META_VAULT:
+      return "A meta vault is a vault that auto allocates funds to multiple vaults based on optimal yield opportunities";
+    case StrategyTag.LEVERED:
+      return "Looping vaults on Endur LSTs with leveraged borrowing of STRK or BTC to increase yield (2-4x higher yield than simply staking)";
+    case StrategyTag.AUTOMATED_LP:
+      return "Automated LP vaults on Ekubo that rebalance position automatically, ensuring you earn fees efficiently";
+    case StrategyTag.BTC:
+      return "BTC linked vaults";
+  }
+}
+
+export const getAllStrategyTags = (): StrategyTag[] => {
+  return Object.values(StrategyTag);
+}
+
 export const getRiskExplaination = (riskType: RiskType) => {
   switch (riskType) {
     case RiskType.MARKET_RISK:
@@ -322,7 +375,7 @@ export function highlightTextWithLinks(
       {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)' }}>
+          <a key={i} href={match.link} target="_blank" style={{ color: 'white', background: 'rgba(255, 255, 255, 0.04)' }}>
             {part}
           </a>
         ) : (
@@ -383,4 +436,9 @@ export const Protocols = {
   VESU: VesuProtocol,
   ENDUR: EndurProtocol,
   EXTENDED: ExtendedProtocol
+}
+
+export const UnwrapLabsCurator: ICurator = {
+  name: "Unwrap Labs",
+  logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
 }

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,

package/src/modules/erc20.ts

@@ -2,7 +2,7 @@ import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig } from "@/interfaces";
 import { Contract } from "starknet";
 import ERC20Abi from '@/data/erc20.abi.json';
-
+import { uint256 } from "starknet";
 export class ERC20 {
     readonly config: IConfig;
 
@@ -12,7 +12,7 @@ export class ERC20 {
 
     contract(addr: string | ContractAddr) {
         const _addr = typeof addr === 'string' ? addr : addr.address;
-        return new Contract({abi: ERC20Abi, address: _addr, providerOrAccount: this.config.provider});
+        return new Contract({ abi: ERC20Abi, address: _addr, providerOrAccount: this.config.provider });
     }
 
     async balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number) {
@@ -26,4 +26,20 @@ export class ERC20 {
         const allowance = await contract.call('allowance', [owner.toString(), spender.toString()]);
         return Web3Number.fromWei(allowance.toString(), tokenDecimals);
     }
+
+    approve(
+        token: string | ContractAddr,
+        spender: string | ContractAddr,
+        amount: Web3Number
+    ) {
+        const contract = this.contract(token);
+        const amountUint256 = uint256.bnToUint256(amount.toWei());
+        const approveCall = contract.populate("approve", [
+            spender.toString(),
+            amountUint256.low.toString(),
+            amountUint256.high.toString(),
+        ]);
+        return approveCall;
+    }
+
 }

package/src/modules/index.ts

@@ -1,4 +1,5 @@
 export * from './pricer';
+export * from './pricer-avnu-api';
 export * from './pragma';
 export * from './zkLend';
 export * from './pricer-from-api';
@@ -6,4 +7,5 @@ export * from './erc20';
 export * from './avnu';
 export * from './ekubo-quoter';
 export * from './pricer-lst';
-export * from './lst-apr';
+export * from './lst-apr';
+export * from './ekubo-pricer'

package/src/modules/pricer-avnu-api.ts

@@ -0,0 +1,114 @@
+import axios from "axios";
+import { TokenInfo } from "@/interfaces/common";
+import { IConfig } from "@/interfaces/common";
+import { PricerBase } from "./pricerBase";
+import { PriceInfo } from "./pricer";
+import { logger } from "@/utils/logger";
+import { ContractAddr } from "@/dataTypes";
+
+const AVNU_TOKENS_API = "https://starknet.impulse.avnu.fi/v3/tokens";
+
+interface AvnuTokenApiEntry {
+    address: string;
+    symbol: string;
+    starknet?: {
+        usd?: number;
+    };
+}
+
+/**
+ * Polls Avnu impulse tokens API and keeps USD prices in memory for configured tokens.
+ * Price timestamp is set when each poll request completes.
+ */
+export class PricerAvnuApi extends PricerBase {
+    protected prices: { [key: string]: PriceInfo } = {};
+
+    readonly refreshInterval = 15_000;
+    readonly staleTime = 5 * 60 * 1000;
+
+    private pollTimer: ReturnType<typeof setInterval> | null = null;
+    private loading = false;
+
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        super(config, tokens);
+    }
+
+    start() {
+        this._loadPrices();
+        this.pollTimer = setInterval(() => {
+            this._loadPrices();
+        }, this.refreshInterval);
+    }
+
+    stop() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+
+    isStale(timestamp: Date) {
+        return Date.now() - timestamp.getTime() > this.staleTime;
+    }
+
+    hasPrice(tokenSymbol: string) {
+        const info = this.prices[tokenSymbol];
+        return !!info && !this.isStale(info.timestamp);
+    }
+
+    async getPrice(tokenSymbol: string): Promise<PriceInfo> {
+        const info = this.prices[tokenSymbol];
+        if (!info) {
+            throw new Error(`AvnuApi: price of ${tokenSymbol} not found`);
+        }
+        if (this.isStale(info.timestamp)) {
+            throw new Error(`AvnuApi: price of ${tokenSymbol} is stale`);
+        }
+        return info;
+    }
+
+    protected async _loadPrices() {
+        if (this.loading) {
+            return;
+        }
+        this.loading = true;
+        const timestamp = new Date();
+        try {
+            const result = await axios.get<AvnuTokenApiEntry[]>(AVNU_TOKENS_API);
+            const priceByAddress = new Map<string, number>();
+            for (const entry of result.data) {
+                const usd = entry.starknet?.usd;
+                if (usd != null && usd > 0) {
+                    priceByAddress.set(ContractAddr.standardise(entry.address), usd);
+                }
+            }
+
+            for (const token of this.tokens) {
+                if (token.symbol === "USDT" || token.symbol === "USDC") {
+                    this.prices[token.symbol] = { price: 1, timestamp };
+                    continue;
+                }
+
+                const targetToken = token.priceProxySymbol
+                    ? this.tokens.find((t) => t.symbol === token.priceProxySymbol)
+                    : token;
+                if (!targetToken) {
+                    continue;
+                }
+
+                const addr = targetToken.address.address;
+                const price = priceByAddress.get(addr);
+                if (price != null) {
+                    this.prices[token.symbol] = { price, timestamp };
+                    logger.verbose(
+                        `AvnuApi: ${token.symbol} -> $${price}`,
+                    );
+                }
+            }
+        } catch (error: any) {
+            logger.warn(`AvnuApi: failed to fetch tokens: ${error?.message ?? error}`);
+        } finally {
+            this.loading = false;
+        }
+    }
+}

package/src/modules/pricer.ts

@@ -1,18 +1,27 @@
 import axios from "axios";
 import { FatalError, Global } from "@/global";
-import { TokenInfo } from "@/interfaces/common";
+import { PriceMethod, TokenInfo } from "@/interfaces/common";
 import { IConfig } from "@/interfaces/common";
 import { Web3Number } from "@/dataTypes";
 import { PricerBase } from "./pricerBase";
 import { logger } from "@/utils/logger";
 import { AvnuWrapper } from "./avnu";
 import { BlockIdentifier } from "starknet";
+import { PricerAvnuApi } from "./pricer-avnu-api";
 
 export interface PriceInfo {
     price: number,
     timestamp: Date
 }
 
+const PRICE_METHOD_PRIORITY: PriceMethod[] = [
+    'AvnuApi',
+    'Coinbase',
+    'Coinmarketcap',
+    'Ekubo',
+    'Avnu',
+];
+
 export class Pricer extends PricerBase {
     protected prices: {
         [key: string]: PriceInfo
@@ -21,9 +30,11 @@ export class Pricer extends PricerBase {
     refreshInterval = 30000;
     staleTime = 60000;
 
+    protected readonly avnuApiPricer: PricerAvnuApi;
+
     // code populates this map during runtime to determine which method to use for a given token
     // The method set will be the first one to try after first attempt
-    protected methodToUse: {[tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap' | 'Avnu'} = {};
+    protected methodToUse: {[tokenSymbol: string]: PriceMethod} = {};
 
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
@@ -36,6 +47,7 @@ export class Pricer extends PricerBase {
         super(config, tokens);
         this.refreshInterval = refreshInterval;
         this.staleTime = staleTime;
+        this.avnuApiPricer = new PricerAvnuApi(config, tokens);
     }
 
     isReady() {
@@ -69,6 +81,7 @@ export class Pricer extends PricerBase {
     }
 
     start() {
+        this.avnuApiPricer.start();
         this._loadPrices();
         setInterval(() => {
             this._loadPrices();
@@ -96,6 +109,9 @@ export class Pricer extends PricerBase {
             let retry = 0;
             while (retry < MAX_RETRIES) {
                 try {
+                    if (token.dontPrice) {
+                        return;
+                    }
                     if (token.symbol === 'USDT' || token.symbol === 'USDC') {
                         this.prices[token.symbol] = {
                             price: 1,
@@ -145,56 +161,70 @@ export class Pricer extends PricerBase {
         }
     }
 
-    async _getPrice(token: TokenInfo, defaultMethod = 'all'): Promise<number> {
-        const methodToUse: string = this.methodToUse[token.symbol] || defaultMethod; // default start with coinbase
-        logger.verbose(`Fetching price of ${token.symbol} using ${methodToUse}`);
-        switch (methodToUse) {
+    async _getPrice(token: TokenInfo): Promise<number> {
+        const methodsToTry = this._getMethodsToTry(token);
+
+        for (const method of methodsToTry) {
+            logger.verbose(`Fetching price of ${token.symbol} using ${method}`);
+            try {
+                const result = await this._tryPriceMethod(token, method);
+                if (!token.priceMethod) {
+                    this.methodToUse[token.symbol] = method;
+                }
+                return result;
+            } catch (error: any) {
+                console.warn(`${method}: price err [${token.symbol}]: `, error.message);
+            }
+        }
+
+        throw new FatalError(`Price not found for ${token.symbol}`);
+    }
+
+    protected _getMethodsToTry(token: TokenInfo): PriceMethod[] {
+        const methods: PriceMethod[] = [];
+
+        if (token.priceMethod) {
+            methods.push(token.priceMethod);
+        }
+
+        const pinned = this.methodToUse[token.symbol];
+        if (pinned && pinned !== token.priceMethod) {
+            methods.push(pinned);
+        }
+
+        for (const method of PRICE_METHOD_PRIORITY) {
+            if (!methods.includes(method)) {
+                methods.push(method);
+            }
+        }
+
+        return methods;
+    }
+
+    protected async _tryPriceMethod(token: TokenInfo, method: PriceMethod): Promise<number> {
+        switch (method) {
+            case 'AvnuApi':
+                return await this._getPriceAvnuApi(token);
             case 'Coinbase':
-                // try {
-                //     const result = await this._getPriceCoinbase(token);
-                //     this.methodToUse[token.symbol] = 'Coinbase';
-                //     return result;
-                // } catch (error: any) {
-                //     console.warn(`Coinbase: price err: message [${token.symbol}]: `, error.message);
-                //     // do nothing, try next
-                // }
+                return await this._getPriceCoinbase(token);
             case 'Coinmarketcap':
-                try {
-                    const result = await this._getPriceCoinMarketCap(token);
-                    this.methodToUse[token.symbol] = 'Coinmarketcap';
-                    return result;
-                } catch (error: any) {
-                    console.warn(`CoinMarketCap: price err [${token.symbol}]: `, Object.keys(error));
-                    console.warn(`CoinMarketCap: price err [${token.symbol}]: `, error.message);
-                }
+                return await this._getPriceCoinMarketCap(token);
             case 'Ekubo':
-                try {
-                    const result = await this._getPriceEkubo(token, new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals));
-                    this.methodToUse[token.symbol] = 'Ekubo';
-                    return result;
-                } catch (error: any) {
-                    console.warn(`Ekubo: price err [${token.symbol}]: `, error.message);
-                    console.warn(`Ekubo: price err [${token.symbol}]: `, Object.keys(error));
-                    // do nothing, try next
-                }
+                return await this._getPriceEkubo(
+                    token,
+                    new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals),
+                );
             case 'Avnu':
-                try {
-                    const result = await this._getAvnuPrice(token, new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals));
-                    this.methodToUse[token.symbol] = 'Avnu';
-                    return result;
-                } catch (error: any) {
-                    console.warn(`Avnu: price err [${token.symbol}]: `, error.message);
-                    console.warn(`Avnu: price err [${token.symbol}]: `, Object.keys(error));
-                }
-        }
-
-        // if methodToUse is the default one, pass Coinbase to try all from start
-        if (defaultMethod == 'all') {
-            // try again with coinbase
-            return await this._getPrice(token, 'Coinbase');
+                return await this._getAvnuPrice(
+                    token,
+                    new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals),
+                );
         }
+    }
 
-        throw new FatalError(`Price not found for ${token.symbol}`);
+    async _getPriceAvnuApi(token: TokenInfo): Promise<number> {
+        const priceInfo = await this.avnuApiPricer.getPrice(token.symbol);
+        return priceInfo.price;
     }
 
     async _getPriceCoinbase(token: TokenInfo) {

package/src/node/pricer-redis.ts

@@ -18,6 +18,7 @@ export class PricerRedis extends Pricer {
         await this.initRedis(redisUrl);
 
         logger.info(`Starting Pricer with Redis`);
+        this.avnuApiPricer.start();
         this._loadPrices(this._setRedisPrices.bind(this));
         setInterval(() => {
             this._loadPrices(this._setRedisPrices.bind(this));