@strkfarm/sdk 1.0.16 → 1.0.18

package/dist/index.d.ts

@@ -1,6 +1,6 @@
+import BigNumber from 'bignumber.js';
 import * as starknet from 'starknet';
 import { RpcProvider, BlockIdentifier, Contract, Account } from 'starknet';
-import BigNumber from 'bignumber.js';
 import * as util from 'util';
 import TelegramBot from 'node-telegram-bot-api';
 
@@ -30,11 +30,25 @@ declare class ContractAddr {
     static eqString(a: string, b: string): boolean;
 }
 
+declare enum RiskType {
+    MARKET_RISK = "MARKET_RISK",
+    IMPERMANENT_LOSS = "IMPERMANENT_LOSS",
+    LIQUIDITY_RISK = "LIQUIDITY_RISK",
+    SMART_CONTRACT_RISK = "SMART_CONTRACT_RISK",
+    TECHNICAL_RISK = "TECHNICAL_RISK",
+    COUNTERPARTY_RISK = "COUNTERPARTY_RISK"
+}
+interface RiskFactor {
+    type: RiskType;
+    value: number;
+    weight: number;
+}
 interface TokenInfo {
     name: string;
     symbol: string;
     address: string;
     decimals: number;
+    logo: string;
     coingeckId?: string;
 }
 declare enum Network {
@@ -52,6 +66,15 @@ interface IProtocol {
     name: string;
     logo: string;
 }
+declare enum FlowChartColors {
+    Green = "purple",
+    Blue = "#35484f",
+    Purple = "#6e53dc"
+}
+/**
+ * @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.
+ */
 interface IStrategyMetadata {
     name: string;
     description: string;
@@ -59,49 +82,23 @@ interface IStrategyMetadata {
     type: 'ERC4626' | 'ERC721' | 'Other';
     depositTokens: TokenInfo[];
     protocols: IProtocol[];
-}
-declare function getMainnetConfig(rpcUrl?: string, blockIdentifier?: BlockIdentifier): IConfig;
-
-interface PriceInfo {
-    price: number;
-    timestamp: Date;
-}
-declare abstract class PricerBase {
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
-}
-declare class Pricer implements PricerBase {
-    readonly config: IConfig;
-    readonly tokens: TokenInfo[];
-    protected prices: {
-        [key: string]: PriceInfo;
+    auditUrl?: string;
+    maxTVL: Web3Number;
+    risk: {
+        riskFactor: RiskFactor[];
+        netRisk: number;
     };
-    private methodToUse;
-    /**
-     * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
-     */
-    protected PRICE_API: string;
-    protected EKUBO_API: string;
-    protected client: any;
-    constructor(config: IConfig, tokens: TokenInfo[]);
-    isReady(): boolean;
-    waitTillReady(): Promise<void>;
-    start(): void;
-    isStale(timestamp: Date, tokenName: string): boolean;
-    assertNotStale(timestamp: Date, tokenName: string): void;
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
-    protected _loadPrices(onUpdate?: (tokenSymbol: string) => void): void;
-    _getPrice(token: TokenInfo, defaultMethod?: string): Promise<number>;
-    _getPriceCoinbase(token: TokenInfo): Promise<number>;
-    _getPriceCoinMarketCap(token: TokenInfo): Promise<number>;
-    _getPriceEkubo(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
 }
-
-declare class Pragma {
-    contractAddr: string;
-    readonly contract: Contract;
-    constructor(provider: RpcProvider);
-    getPrice(tokenAddr: string): Promise<number>;
+interface IInvestmentFlow {
+    title: string;
+    subItems: {
+        key: string;
+        value: string;
+    }[];
+    linkedFlows: IInvestmentFlow[];
+    style?: any;
 }
+declare function getMainnetConfig(rpcUrl?: string, blockIdentifier?: BlockIdentifier): IConfig;
 
 interface ILendingMetadata {
     name: string;
@@ -155,6 +152,48 @@ declare abstract class Initializable {
     waitForInitilisation(): Promise<void>;
 }
 
+declare abstract class PricerBase {
+    readonly config: IConfig;
+    readonly tokens: TokenInfo[];
+    constructor(config: IConfig, tokens: TokenInfo[]);
+    getPrice(tokenSymbol: string): Promise<PriceInfo>;
+}
+
+interface PriceInfo {
+    price: number;
+    timestamp: Date;
+}
+declare class Pricer extends PricerBase {
+    protected prices: {
+        [key: string]: PriceInfo;
+    };
+    private methodToUse;
+    /**
+     * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
+     */
+    protected PRICE_API: string;
+    protected EKUBO_API: string;
+    constructor(config: IConfig, tokens: TokenInfo[]);
+    isReady(): boolean;
+    waitTillReady(): Promise<void>;
+    start(): void;
+    isStale(timestamp: Date, tokenName: string): boolean;
+    assertNotStale(timestamp: Date, tokenName: string): void;
+    getPrice(tokenSymbol: string): Promise<PriceInfo>;
+    protected _loadPrices(onUpdate?: (tokenSymbol: string) => void): void;
+    _getPrice(token: TokenInfo, defaultMethod?: string): Promise<number>;
+    _getPriceCoinbase(token: TokenInfo): Promise<number>;
+    _getPriceCoinMarketCap(token: TokenInfo): Promise<number>;
+    _getPriceEkubo(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
+}
+
+declare class Pragma {
+    contractAddr: string;
+    readonly contract: Contract;
+    constructor(provider: RpcProvider);
+    getPrice(tokenAddr: string): Promise<number>;
+}
+
 declare class ZkLend extends ILending implements ILending {
     readonly pricer: Pricer;
     static readonly POOLS_URL = "https://app.zklend.com/api/pools";
@@ -186,6 +225,15 @@ declare class ZkLend extends ILending implements ILending {
     getPositions(user: ContractAddr): Promise<ILendingPosition[]>;
 }
 
+declare class PricerFromApi extends PricerBase {
+    constructor(config: IConfig, tokens: TokenInfo[]);
+    getPrice(tokenSymbol: string): Promise<PriceInfo>;
+    getPriceFromMyAPI(tokenSymbol: string): Promise<{
+        price: number;
+        timestamp: Date;
+    }>;
+}
+
 declare const logger: {
     verbose(message: string): void;
     assert(condition?: boolean, ...data: any[]): void;
@@ -441,6 +489,7 @@ declare class VesuRebalance {
      * @returns Populated contract call for rebalance
      */
     getRebalanceCall(pools: Awaited<ReturnType<typeof this.getRebalancedPositions>>['changes'], isOverWeightAdjustment: boolean): Promise<starknet.Call | null>;
+    getInvestmentFlows(pools: PoolInfoFull[]): Promise<IInvestmentFlow[]>;
 }
 /**
  * Represents the Vesu Rebalance Strategies.
@@ -554,4 +603,4 @@ declare class PasswordJsonCryptoUtil {
     decrypt(encryptedData: string, password: string): any;
 }
 
-export { type AccountInfo, type AllAccountsStore, AutoCompounderSTRK, ContractAddr, FatalError, Global, type IConfig, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, Initializable, type LendingToken, MarginType, Network, PasswordJsonCryptoUtil, Pragma, type PriceInfo, Pricer, PricerBase, PricerRedis, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, Store, type StoreConfig, TelegramNotif, type TokenInfo, VesuRebalance, VesuRebalanceStrategies, Web3Number, ZkLend, assert, getDefaultStoreConfig, getMainnetConfig, logger };
+export { type AccountInfo, type AllAccountsStore, AutoCompounderSTRK, ContractAddr, FatalError, FlowChartColors, Global, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, Initializable, type LendingToken, MarginType, Network, PasswordJsonCryptoUtil, Pragma, type PriceInfo, Pricer, PricerFromApi, PricerRedis, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, Store, type StoreConfig, TelegramNotif, type TokenInfo, VesuRebalance, VesuRebalanceStrategies, Web3Number, ZkLend, assert, getDefaultStoreConfig, getMainnetConfig, logger };

package/dist/index.js

@@ -33,6 +33,7 @@ __export(src_exports, {
   AutoCompounderSTRK: () => AutoCompounderSTRK,
   ContractAddr: () => ContractAddr,
   FatalError: () => FatalError,
+  FlowChartColors: () => FlowChartColors,
   Global: () => Global,
   ILending: () => ILending,
   Initializable: () => Initializable,
@@ -41,8 +42,9 @@ __export(src_exports, {
   PasswordJsonCryptoUtil: () => PasswordJsonCryptoUtil,
   Pragma: () => Pragma,
   Pricer: () => Pricer,
-  PricerBase: () => PricerBase,
+  PricerFromApi: () => PricerFromApi,
   PricerRedis: () => PricerRedis,
+  RiskType: () => RiskType,
   Store: () => Store,
   TelegramNotif: () => TelegramNotif,
   VesuRebalance: () => VesuRebalance,
@@ -79,6 +81,7 @@ var FatalError = class extends Error {
 var tokens = [{
   name: "Starknet",
   symbol: "STRK",
+  logo: "https://assets.coingecko.com/coins/images/26433/small/starknet.png",
   address: "0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
   decimals: 18,
   coingeckId: "starknet"
@@ -111,6 +114,7 @@ var Global = class {
         symbol: token.symbol,
         address: token.address,
         decimals: token.decimals,
+        logo: token.logoUri,
         coingeckId: token.extensions.coingeckoId
       });
     });
@@ -190,16 +194,22 @@ var ContractAddr = class _ContractAddr {
   }
 };
 
-// src/modules/pricer.ts
-var CoinMarketCap = require("coinmarketcap-api");
+// src/modules/pricerBase.ts
 var PricerBase = class {
+  constructor(config, tokens2) {
+    this.config = config;
+    this.tokens = tokens2;
+  }
   async getPrice(tokenSymbol) {
     throw new Error("Method not implemented");
   }
 };
-var Pricer = class {
+
+// src/modules/pricer.ts
+var Pricer = class extends PricerBase {
+  // e.g. ETH/USDC
   constructor(config, tokens2) {
-    this.tokens = [];
+    super(config, tokens2);
     this.prices = {};
     // 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
@@ -209,11 +219,6 @@ var Pricer = class {
      */
     this.PRICE_API = `https://api.coinbase.com/v2/prices/{{PRICER_KEY}}/buy`;
     this.EKUBO_API = "https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_ADDRESS}}/0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8";
-    // e.g. ETH/USDC
-    // backup oracle001
-    this.client = new CoinMarketCap(process.env.COINMARKETCAP_KEY);
-    this.config = config;
-    this.tokens = tokens2;
   }
   isReady() {
     const allPricesExist = Object.keys(this.prices).length === this.tokens.length;
@@ -345,10 +350,7 @@ var Pricer = class {
     return Number(data.data.amount);
   }
   async _getPriceCoinMarketCap(token) {
-    const result = await this.client.getQuotes({ symbol: token.symbol });
-    if (result.data)
-      return result.data[token.symbol].quote.USD.price;
-    throw new Error(result);
+    throw new Error("Not implemented");
   }
   async _getPriceEkubo(token, amountIn = new Web3Number(1, token.decimals), retry = 0) {
     const url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address).replace("{{AMOUNT}}", amountIn.toWei());
@@ -542,6 +544,7 @@ var _ZkLend = class _ZkLend extends ILending {
           name: pool.token.name,
           symbol: pool.token.symbol,
           address: savedTokenInfo?.address || "",
+          logo: "",
           decimals: pool.token.decimals,
           borrowFactor: Web3Number.fromWei(pool.borrow_factor.value, pool.borrow_factor.decimals),
           collareralFactor
@@ -651,14 +654,84 @@ var _ZkLend = class _ZkLend extends ILending {
 _ZkLend.POOLS_URL = "https://app.zklend.com/api/pools";
 var ZkLend = _ZkLend;
 
+// src/modules/pricer-from-api.ts
+var import_axios4 = __toESM(require("axios"));
+var PricerFromApi = class extends PricerBase {
+  constructor(config, tokens2) {
+    super(config, tokens2);
+  }
+  async getPrice(tokenSymbol) {
+    try {
+      return await this.getPriceFromMyAPI(tokenSymbol);
+    } catch (e) {
+      logger.warn("getPriceFromMyAPI error", e);
+    }
+    logger.log("getPrice coinbase", tokenSymbol);
+    let retry = 0;
+    const MAX_RETRIES = 5;
+    for (retry = 1; retry < MAX_RETRIES + 1; retry++) {
+      try {
+        const priceInfo = await import_axios4.default.get(
+          `https://api.coinbase.com/v2/prices/${tokenSymbol}-USDT/spot`
+        );
+        if (!priceInfo) {
+          throw new Error("Failed to fetch price");
+        }
+        const data = await priceInfo.data;
+        const price = Number(data.data.amount);
+        return {
+          price,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      } catch (e) {
+        logger.warn("getPrice coinbase error", e, retry);
+        await new Promise((resolve) => setTimeout(resolve, retry * 1e3));
+      }
+    }
+    throw new Error(`Failed to fetch price for ${tokenSymbol}`);
+  }
+  async getPriceFromMyAPI(tokenSymbol) {
+    logger.verbose(`getPrice from redis: ${tokenSymbol}`);
+    const endpoint = "https://app.strkfarm.com";
+    const url = `${endpoint}/api/price/${tokenSymbol}`;
+    const priceInfoRes = await fetch(url);
+    const priceInfo = await priceInfoRes.json();
+    const now = /* @__PURE__ */ new Date();
+    const priceTime = new Date(priceInfo.timestamp);
+    if (now.getTime() - priceTime.getTime() > 9e5) {
+      throw new Error("Price is stale");
+    }
+    const price = Number(priceInfo.price);
+    return {
+      price,
+      timestamp: new Date(priceInfo.timestamp)
+    };
+  }
+};
+
 // src/interfaces/common.ts
 var import_starknet3 = require("starknet");
+var RiskType = /* @__PURE__ */ ((RiskType2) => {
+  RiskType2["MARKET_RISK"] = "MARKET_RISK";
+  RiskType2["IMPERMANENT_LOSS"] = "IMPERMANENT_LOSS";
+  RiskType2["LIQUIDITY_RISK"] = "LIQUIDITY_RISK";
+  RiskType2["SMART_CONTRACT_RISK"] = "SMART_CONTRACT_RISK";
+  RiskType2["TECHNICAL_RISK"] = "TECHNICAL_RISK";
+  RiskType2["COUNTERPARTY_RISK"] = "COUNTERPARTY_RISK";
+  return RiskType2;
+})(RiskType || {});
 var Network = /* @__PURE__ */ ((Network2) => {
   Network2["mainnet"] = "mainnet";
   Network2["sepolia"] = "sepolia";
   Network2["devnet"] = "devnet";
   return Network2;
 })(Network || {});
+var FlowChartColors = /* @__PURE__ */ ((FlowChartColors2) => {
+  FlowChartColors2["Green"] = "purple";
+  FlowChartColors2["Blue"] = "#35484f";
+  FlowChartColors2["Purple"] = "#6e53dc";
+  return FlowChartColors2;
+})(FlowChartColors || {});
 function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blastapi.io", blockIdentifier = "pending") {
   return {
     provider: new import_starknet3.RpcProvider({
@@ -2234,7 +2307,7 @@ function assert(condition, message) {
 }
 
 // src/strategies/vesu-rebalance.ts
-var import_axios4 = __toESM(require("axios"));
+var import_axios5 = __toESM(require("axios"));
 var VesuRebalance = class _VesuRebalance {
   // 10000 bps = 100%
   /**
@@ -2341,7 +2414,7 @@ var VesuRebalance = class _VesuRebalance {
     let isErrorPositionsAPI = false;
     let vesuPositions = [];
     try {
-      const res = await import_axios4.default.get(`https://api.vesu.xyz/positions?walletAddress=${this.address.address}`);
+      const res = await import_axios5.default.get(`https://api.vesu.xyz/positions?walletAddress=${this.address.address}`);
       const data2 = await res.data;
       vesuPositions = data2.data;
     } catch (e) {
@@ -2351,7 +2424,7 @@ var VesuRebalance = class _VesuRebalance {
     let isErrorPoolsAPI = false;
     let pools = [];
     try {
-      const res = await import_axios4.default.get(`https://api.vesu.xyz/pools`);
+      const res = await import_axios5.default.get(`https://api.vesu.xyz/pools`);
       const data2 = await res.data;
       pools = data2.data;
     } catch (e) {
@@ -2368,7 +2441,7 @@ var VesuRebalance = class _VesuRebalance {
       const assets = await vTokenContract.convert_to_assets(import_starknet5.uint256.bnToUint256(bal.toString()));
       const item = {
         pool_id: p.pool_id,
-        pool_name: vesuPosition?.pool.name,
+        pool_name: pool.name,
         max_weight: p.max_weight,
         current_weight: isErrorPositionsAPI || !vesuPosition ? 0 : Number(Web3Number.fromWei(vesuPosition.collateral.value, this.decimals()).dividedBy(totalAssets.toString()).toFixed(6)),
         v_token: p.v_token,
@@ -2511,16 +2584,50 @@ var VesuRebalance = class _VesuRebalance {
     }
     return this.contract.populate("rebalance", [actions]);
   }
+  async getInvestmentFlows(pools) {
+    const netYield = this.netAPYGivenPools(pools);
+    const baseFlow = {
+      title: "Your Deposit",
+      subItems: [{ key: `Net yield`, value: `${(netYield * 100).toFixed(2)}%` }],
+      linkedFlows: [],
+      style: { backgroundColor: "#6e53dc" /* Purple */.valueOf() }
+    };
+    let _pools = [...pools];
+    _pools = _pools.sort((a, b) => Number(b.amount.toString()) - Number(a.amount.toString()));
+    _pools.forEach((p) => {
+      const flow = {
+        title: `Pool name: ${p.pool_name}`,
+        subItems: [
+          { key: `APY`, value: `${(p.APY.netApy * 100).toFixed(2)}%` },
+          { key: "Weight", value: `${(p.current_weight * 100).toFixed(2)} / ${(p.max_weight * 100).toFixed(2)}%` }
+        ],
+        linkedFlows: [],
+        style: p.amount.greaterThan(0) ? { backgroundColor: "#35484f" /* Blue */.valueOf() } : { color: "gray" }
+      };
+      baseFlow.linkedFlows.push(flow);
+    });
+    return [baseFlow];
+  }
 };
 var _description = "Automatically diversify {{TOKEN}} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring STRK Rewards are auto-compounded as well.";
 var _protocol = { name: "Vesu", logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png" };
+var _riskFactor = [
+  { type: "SMART_CONTRACT_RISK" /* SMART_CONTRACT_RISK */, value: 0.5, weight: 25 },
+  { type: "TECHNICAL_RISK" /* TECHNICAL_RISK */, value: 0.5, weight: 25 },
+  { type: "COUNTERPARTY_RISK" /* COUNTERPARTY_RISK */, value: 1, weight: 50 }
+];
 var VesuRebalanceStrategies = [{
   name: "Vesu STRK",
   description: _description.replace("{{TOKEN}}", "STRK"),
   address: ContractAddr.from("0xeeb729d554ae486387147b13a9c8871bc7991d454e8b5ff570d4bf94de71e1"),
   type: "ERC4626",
   depositTokens: [Global.getDefaultTokens().find((t) => t.symbol === "STRK")],
-  protocols: [_protocol]
+  protocols: [_protocol],
+  maxTVL: Web3Number.fromWei("0", 18),
+  risk: {
+    riskFactor: _riskFactor,
+    netRisk: _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / 100
+  }
 }];
 
 // src/notifs/telegram.ts
@@ -2789,6 +2896,7 @@ var Store = class _Store {
   AutoCompounderSTRK,
   ContractAddr,
   FatalError,
+  FlowChartColors,
   Global,
   ILending,
   Initializable,
@@ -2797,8 +2905,9 @@ var Store = class _Store {
   PasswordJsonCryptoUtil,
   Pragma,
   Pricer,
-  PricerBase,
+  PricerFromApi,
   PricerRedis,
+  RiskType,
   Store,
   TelegramNotif,
   VesuRebalance,