@strkfarm/sdk 2.0.0-dev.40 → 2.0.0-dev.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "2.0.0-dev.40",
+  "version": "2.0.0-dev.41",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",
@@ -38,9 +38,6 @@
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "publishConfig": {
-    "tag": "dev"
-  },
   "devDependencies": {
     "@types/jest": "^29.5.12",
     "@types/node-telegram-bot-api": "^0.64.7",
@@ -59,6 +56,9 @@
     "react": "19.1.2",
     "starknet": "9.2.1"
   },
+  "publishConfig": {
+    "tag": "staging"
+  },
   "dependencies": {
     "@apollo/client": "3.11.8",
     "@avnu/avnu-sdk": "3.0.2",
@@ -70,7 +70,6 @@
     "browser-assert": "^1.2.1",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
-    "dotenv": "^17.2.3",
     "ethers": "^6.13.5",
     "graphql": "16.9.0",
     "inquirer": "^10.1.2",

package/src/global.ts

@@ -48,7 +48,7 @@ const defaultTokens: TokenInfo[] = [
     coingeckId: undefined,
     priceCheckAmount: 0.1,
     displayDecimals: 6,
-}, {
+  }, {
     name: 'USDC.e',
     symbol: 'USDC.e',
     logo: 'https://assets.troves.fi/integrations/tokens/usdc.svg',
@@ -58,7 +58,7 @@ const defaultTokens: TokenInfo[] = [
     displayDecimals: 2,
     priceCheckAmount: 1000,
     priceProxySymbol: 'USDC'
-}, {
+  }, {
     name: 'USDC',
     symbol: 'USDC',
     logo: 'https://assets.troves.fi/integrations/tokens/usdc.svg',
@@ -169,7 +169,7 @@ const defaultTokens: TokenInfo[] = [
     displayDecimals: 6,
     priceCheckAmount: 0.001, // 112000 * 0.0001 = $110.2
     priceProxySymbol: 'WBTC',
-}, {
+  }, {
     name: 'xLBTC',
     symbol: 'xLBTC',
     logo: 'https://assets.strkfarm.com/integrations/tokens/xlbtc.svg',
@@ -191,19 +191,18 @@ const defaultTokens: TokenInfo[] = [
     coingeckId: undefined,
     displayDecimals: 6,
     priceCheckAmount: 0.0001, // 112000 * 0.0001 = $11.2
-  },
-  {
-    name: "mRe7YIELD",
-    symbol: "mRe7YIELD",
-    logo: "https://midas.app/assets/mre7-BcOOHm7i.svg",
-    address: ContractAddr.from(
-      "0x4be8945e61dc3e19ebadd1579a6bd53b262f51ba89e6f8b0c4bc9a7e3c633fc"
-    ),
+    dontPrice: true,
+  }, {
+    name: 'mRe7YIELD',
+    symbol: 'mRe7YIELD',
+    logo: 'https://midas.app/assets/mre7-BcOOHm7i.svg',
+    address: ContractAddr.from('0x4be8945e61dc3e19ebadd1579a6bd53b262f51ba89e6f8b0c4bc9a7e3c633fc'),
     decimals: 18,
     coingeckId: undefined,
     displayDecimals: 2,
     priceCheckAmount: 100,
-}, {
+    dontPrice: true,
+  }, {
     name: "fyWBTC",
     symbol: "fyWBTC",
     logo: 'https://assets.strkfarm.com/integrations/tokens/wbtc.svg',
@@ -212,7 +211,8 @@ const defaultTokens: TokenInfo[] = [
     coingeckId: undefined,
     displayDecimals: 6,
     priceCheckAmount: 0.001, // 112000 * 0.0001 = $110.2
-}, {
+    dontPrice: true,
+  }, {
     name: "fyETH",
     symbol: "fyETH",
     logo: 'https://assets.strkfarm.com/integrations/tokens/eth.svg',
@@ -221,7 +221,8 @@ const defaultTokens: TokenInfo[] = [
     coingeckId: undefined,
     displayDecimals: 4,
     priceCheckAmount: 0.1,
-}, {
+    dontPrice: true,
+  }, {
     name: "fyUSDC",
     symbol: "fyUSDC",
     logo: 'https://assets.strkfarm.com/integrations/tokens/usdc.svg',
@@ -230,7 +231,8 @@ const defaultTokens: TokenInfo[] = [
     coingeckId: undefined,
     displayDecimals: 2,
     priceCheckAmount: 100,
-}, {
+    dontPrice: true,
+  }, {
     name: 'strkBTC',
     symbol: 'strkBTC',
     logo: 'https://assets.troves.fi/integrations/tokens/strkbtc.svg',
@@ -240,7 +242,7 @@ const defaultTokens: TokenInfo[] = [
     displayDecimals: 6,
     priceCheckAmount: 0.001, // 112000 * 0.0001 = $110.2
     priceProxySymbol: 'WBTC',
-}, {
+  }, {
     name: 'xstrkBTC',
     symbol: 'xstrkBTC',
     logo: 'https://assets.troves.fi/integrations/tokens/xstrkbtc.svg',
@@ -250,7 +252,7 @@ const defaultTokens: TokenInfo[] = [
     displayDecimals: 6,
     priceCheckAmount: 0.001,
     priceProxySymbol: 'WBTC',
-},]
+  },]
 const tokens: TokenInfo[] = defaultTokens;
 
 /** Contains globally useful functions.
@@ -333,14 +335,14 @@ export class Global {
   static async getTokenInfoFromName(tokenName: string) {
     // if tokens are not loaded, load them
     if (tokens.length == defaultTokens.length) {
-        await Global.getTokens();
+      await Global.getTokens();
     }
 
     const token = tokens.find(
-        (token) => token.name.toLowerCase() === tokenName.toLowerCase()
+      (token) => token.name.toLowerCase() === tokenName.toLowerCase()
     );
     if (!token) {
-        throw new FatalError(`Token not found: ${tokenName}`);
+      throw new FatalError(`Token not found: ${tokenName}`);
     }
     return token;
   }
@@ -348,30 +350,30 @@ export class Global {
   static async getTokenInfoFromAddr(addr: ContractAddr) {
     // if tokens are not loaded, load them
     if (tokens.length == defaultTokens.length) {
-        await Global.getTokens();
+      await Global.getTokens();
     }
     const token = tokens.find((token) => addr.eq(token.address));
     if (!token) {
-        throw new FatalError(`Token not found: ${addr.address}`);
+      throw new FatalError(`Token not found: ${addr.address}`);
     }
     return token;
   }
 
   static setGlobalCache(key: string, data: any, ttl: number = 60000) {
-      Global.cache[key] = {
-          value: data,
-          ttl,
-          timestamp: Date.now()
-      };
+    Global.cache[key] = {
+      value: data,
+      ttl,
+      timestamp: Date.now()
+    };
   }
 
   static getGlobalCache<T>(key: string): T | null {
-      const cached = Global.cache[key];
-      if (!cached) return null;
-      if (Date.now() - cached.timestamp > cached.ttl) {
-          delete Global.cache[key];
-          return null;
-      }
-      return cached.value;
+    const cached = Global.cache[key];
+    if (!cached) return null;
+    if (Date.now() - cached.timestamp > cached.ttl) {
+      delete Global.cache[key];
+      return null;
+    }
+    return cached.value;
   }
 }

package/src/interfaces/common.tsx

@@ -35,6 +35,7 @@ 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
+  dontPrice?: boolean; // a flag that skips pricer to check these tokens. 
 }
 
 export enum Network {
@@ -174,6 +175,10 @@ export interface StrategyApyHistoryUIConfig {
   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.
@@ -214,6 +219,7 @@ export interface IStrategyMetadata<T> {
   };
   apyMethodology?: string;
   realizedApyMethodology?: string;
+  feeBps?: FeeBps;
   additionalInfo: T;
   contractDetails: {
     address: ContractAddr;

package/src/modules/index.ts

@@ -1,5 +1,6 @@
 export * from './token-market-data';
 export * from './pricer';
+export * from './pricer-avnu-api';
 export * from './pragma';
 export * from './zkLend';
 export * from './pricer-from-api';

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

@@ -7,12 +7,23 @@ 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
 }
 
+type PriceMethod = 'AvnuApi' | 'Coinbase' | 'Coinmarketcap' | 'Ekubo' | 'Avnu';
+
+const PRICE_METHOD_PRIORITY: PriceMethod[] = [
+    'AvnuApi',
+    'Coinbase',
+    'Coinmarketcap',
+    'Ekubo',
+    'Avnu',
+];
+
 export class Pricer extends PricerBase {
     protected prices: {
         [key: string]: PriceInfo
@@ -21,9 +32,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 +49,7 @@ export class Pricer extends PricerBase {
         super(config, tokens);
         this.refreshInterval = refreshInterval;
         this.staleTime = staleTime;
+        this.avnuApiPricer = new PricerAvnuApi(config, tokens);
     }
 
     isReady() {
@@ -69,6 +83,7 @@ export class Pricer extends PricerBase {
     }
 
     start() {
+        this.avnuApiPricer.start();
         this._loadPrices();
         setInterval(() => {
             this._loadPrices();
@@ -96,6 +111,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 +163,56 @@ 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 pinned = this.methodToUse[token.symbol];
+        if (pinned) {
+            logger.verbose(`Fetching price of ${token.symbol} using pinned ${pinned}`);
+            try {
+                return await this._tryPriceMethod(token, pinned);
+            } catch (error: any) {
+                console.warn(`${pinned}: pinned price failed [${token.symbol}]: `, error.message);
+                delete this.methodToUse[token.symbol];
+            }
+        }
+
+        for (const method of PRICE_METHOD_PRIORITY) {
+            logger.verbose(`Fetching price of ${token.symbol} using ${method}`);
+            try {
+                const result = await this._tryPriceMethod(token, method);
+                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 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));

package/src/strategies/ekubo-cl-vault.tsx

@@ -2452,6 +2452,9 @@ const xSTRKSTRK: IStrategyMetadata<CLVaultStrategySettings> = {
   apyMethodology:
     "APY based on 30-day historical performance, including fees and rewards.",
   realizedApyMethodology: "The realizedAPY is based on past 14 days performance by the vault",
+  feeBps: {
+    performanceFeeBps: 1000,
+  },
   additionalInfo: {
     newBounds: {
       lower: -1,