@strkfarm/sdk 1.0.53 → 1.0.55

package/dist/index.js

@@ -50,6 +50,8 @@ __export(src_exports, {
   PricerFromApi: () => PricerFromApi,
   PricerRedis: () => PricerRedis,
   RiskType: () => RiskType,
+  SenseiStrategies: () => SenseiStrategies,
+  SenseiVault: () => SenseiVault,
   Store: () => Store,
   TelegramNotif: () => TelegramNotif,
   VesuRebalance: () => VesuRebalance,
@@ -63,6 +65,7 @@ __export(src_exports, {
   getNoRiskTags: () => getNoRiskTags,
   getRiskColor: () => getRiskColor,
   getRiskExplaination: () => getRiskExplaination,
+  getTrovesEndpoint: () => getTrovesEndpoint,
   highlightTextWithLinks: () => highlightTextWithLinks,
   logger: () => logger
 });
@@ -124,6 +127,19 @@ var _Web3Number = class extends import_bignumber.default {
     }
     return value.toFixed(this.maxToFixedDecimals());
   }
+  minimum(value) {
+    const _value = new import_bignumber.default(value);
+    const _valueMe = new import_bignumber.default(this.toString());
+    const answer = _value.lessThanOrEqualTo(_valueMe) ? _value : _valueMe;
+    return this.construct(answer.toString(), this.decimals);
+  }
+  maximum(value) {
+    const _value = new import_bignumber.default(value);
+    const _valueMe = new import_bignumber.default(this.toString());
+    console.warn(`maximum: _value: ${_value.toString()}, _valueMe: ${_valueMe.toString()}`);
+    const answer = _value.greaterThanOrEqualTo(_valueMe) ? _value : _valueMe;
+    return this.construct(answer.toString(), this.decimals);
+  }
 };
 import_bignumber.default.config({ DECIMAL_PLACES: 18, ROUNDING_MODE: import_bignumber.default.ROUND_DOWN });
 _Web3Number.config({ DECIMAL_PLACES: 18, ROUNDING_MODE: import_bignumber.default.ROUND_DOWN });
@@ -2005,6 +2021,9 @@ function assert(condition, message) {
     throw new Error(message);
   }
 }
+function getTrovesEndpoint() {
+  return process.env.TROVES_ENDPOINT || "https://app.troves.fi";
+}
 
 // src/modules/avnu.ts
 var AvnuWrapper = class _AvnuWrapper {
@@ -2030,7 +2049,6 @@ var AvnuWrapper = class _AvnuWrapper {
       }
       throw new Error("no quotes found");
     }
-    logger.verbose(`${_AvnuWrapper.name}: getQuotes => Found ${JSON.stringify(filteredQuotes[0])}`);
     return filteredQuotes[0];
   }
   async getSwapInfo(quote, taker, integratorFeeBps, integratorFeeRecipient, minAmount) {
@@ -2097,6 +2115,7 @@ var RiskType = /* @__PURE__ */ ((RiskType2) => {
   RiskType2["ORACLE_RISK"] = "Oracle Risk";
   RiskType2["TECHNICAL_RISK"] = "Technical Risk";
   RiskType2["COUNTERPARTY_RISK"] = "Counterparty Risk";
+  RiskType2["DEPEG_RISK"] = "Depeg Risk";
   return RiskType2;
 })(RiskType || {});
 var Network = /* @__PURE__ */ ((Network2) => {
@@ -2111,7 +2130,7 @@ var FlowChartColors = /* @__PURE__ */ ((FlowChartColors2) => {
   FlowChartColors2["Purple"] = "#6e53dc";
   return FlowChartColors2;
 })(FlowChartColors || {});
-function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blastapi.io", blockIdentifier = "pending") {
+function getMainnetConfig(rpcUrl, blockIdentifier = "pending") {
   return {
     provider: new import_starknet5.RpcProvider({
       nodeUrl: rpcUrl,
@@ -2139,6 +2158,8 @@ var getRiskExplaination = (riskType) => {
       return "The risk of technical issues e.g. backend failure.";
     case "Counterparty Risk" /* COUNTERPARTY_RISK */:
       return "The risk of the counterparty defaulting e.g. bad debt on lending platforms.";
+    case "Depeg Risk" /* DEPEG_RISK */:
+      return "The risk of a token losing its peg to the underlying asset, leading to potential losses for holders.";
   }
 };
 var getRiskColor = (risk) => {
@@ -3727,6 +3748,7 @@ var vesu_rebalance_abi_default = [
 // src/strategies/base-strategy.ts
 var BaseStrategy = class {
   constructor(config) {
+    this.cache = /* @__PURE__ */ new Map();
     this.config = config;
   }
   async getUserTVL(user) {
@@ -3741,6 +3763,23 @@ var BaseStrategy = class {
   async withdrawCall(amountInfo, receiver, owner) {
     throw new Error("Not implemented");
   }
+  setCache(key, data, ttl = 6e4) {
+    const timestamp = Date.now();
+    this.cache.set(key, { timestamp, ttl, data });
+  }
+  getCache(key) {
+    const cachedData = this.cache.get(key);
+    if (!cachedData || !this.isCacheValid(key)) {
+      return null;
+    }
+    return cachedData.data;
+  }
+  isCacheValid(key) {
+    const cachedData = this.cache.get(key);
+    if (!cachedData) return false;
+    const { timestamp, ttl } = cachedData;
+    return Date.now() - timestamp <= ttl;
+  }
 };
 
 // src/node/headless.browser.ts
@@ -16058,11 +16097,19 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           import_starknet9.uint256.uint256ToBN(swapInfo1.token_from_amount).toString(),
           18
           // cause its always STRK?
+        ).minimum(
+          postFeeAmount.toFixed(18)
+          // cause always strk
+        );
+        swapInfo.token_from_amount = import_starknet9.uint256.bnToUint256(swap1Amount.toWei());
+        swapInfo.token_to_min_amount = import_starknet9.uint256.bnToUint256(
+          swap1Amount.multipliedBy(0).toWei()
+          // placeholder
         );
         logger.verbose(
           `${_EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
         );
-        const remainingAmount = postFeeAmount.minus(swap1Amount);
+        const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
         logger.verbose(
           `${_EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
         );
@@ -16102,7 +16149,12 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       const _callsFinal = await this.rebalanceIter(
         swapInfo,
         acc,
-        harvestEstimateCall
+        harvestEstimateCall,
+        claim.token.eq(poolKey.token0),
+        0,
+        0n,
+        BigInt(postFeeAmount.toWei())
+        // upper limit is the post fee amount
       );
       logger.verbose(
         `${_EkuboCLVault.name}: harvest => _callsFinal: ${JSON.stringify(
@@ -16344,113 +16396,2154 @@ EkuboCLVaultStrategies.forEach((s) => {
   ];
 });
 
-// src/notifs/telegram.ts
-var import_node_telegram_bot_api = __toESM(require("node-telegram-bot-api"));
-var TelegramNotif = class {
-  constructor(token, shouldPoll) {
-    this.subscribers = [
-      // '6820228303',
-      "1505578076",
-      // '5434736198', // maaza
-      "1356705582",
-      // langs
-      "1388729514",
-      // hwashere
-      "6020162572",
-      //minato
-      "985902592"
-    ];
-    this.bot = new import_node_telegram_bot_api.default(token, { polling: shouldPoll });
-  }
-  // listen to start msgs, register chatId and send registered msg
-  activateChatBot() {
-    this.bot.on("message", (msg) => {
-      const chatId = msg.chat.id;
-      let text = msg.text.toLowerCase().trim();
-      logger.verbose(`Tg: IncomingMsg: ID: ${chatId}, msg: ${text}`);
-      if (text == "start") {
-        this.bot.sendMessage(chatId, "Registered");
-        this.subscribers.push(chatId);
-        logger.verbose(`Tg: New subscriber: ${chatId}`);
-      } else {
-        this.bot.sendMessage(chatId, "Unrecognized command. Supported commands: start");
-      }
-    });
-  }
-  // send a given msg to all registered users
-  sendMessage(msg) {
-    logger.verbose(`Tg: Sending message: ${msg}`);
-    for (let chatId of this.subscribers) {
-      this.bot.sendMessage(chatId, msg).catch((err) => {
-        logger.error(`Tg: Error sending msg to ${chatId}`);
-        logger.error(`Tg: Error sending message: ${err.message}`);
-      }).then(() => {
-        logger.verbose(`Tg: Message sent to ${chatId}`);
-      });
-    }
-  }
-};
-
-// src/node/pricer-redis.ts
-var import_redis = require("redis");
-var PricerRedis = class extends Pricer {
-  constructor(config, tokens2) {
-    super(config, tokens2);
-    this.redisClient = null;
-  }
-  /** Reads prices from Pricer._loadPrices and uses a callback to set prices in redis */
-  async startWithRedis(redisUrl) {
-    await this.initRedis(redisUrl);
-    logger.info(`Starting Pricer with Redis`);
-    this._loadPrices(this._setRedisPrices.bind(this));
-    setInterval(() => {
-      this._loadPrices(this._setRedisPrices.bind(this));
-    }, 3e4);
-  }
-  async close() {
-    if (this.redisClient) {
-      await this.redisClient.disconnect();
-    }
-  }
-  async initRedis(redisUrl) {
-    logger.info(`Initialising Redis Client`);
-    this.redisClient = await (0, import_redis.createClient)({
-      url: redisUrl
-    });
-    this.redisClient.on("error", (err) => console.log("Redis Client Error", err)).connect();
-    logger.info(`Redis Client Initialised`);
-  }
-  /** sets current local price in redis */
-  _setRedisPrices(tokenSymbol) {
-    if (!this.redisClient) {
-      throw new FatalError(`Redis client not initialised`);
-    }
-    this.redisClient.set(`Price:${tokenSymbol}`, JSON.stringify(this.prices[tokenSymbol])).catch((err) => {
-      logger.warn(`Error setting price in redis for ${tokenSymbol}`);
-    });
-  }
-  /** Returns price from redis */
-  async getPrice(tokenSymbol) {
-    const STALE_TIME = 6e4;
-    if (!this.redisClient) {
-      throw new FatalError(`Redis client not initialised`);
-    }
-    const data = await this.redisClient.get(`Price:${tokenSymbol}`);
-    if (!data) {
-      throw new FatalError(`Redis:Price of ${tokenSymbol} not found`);
-    }
-    logger.verbose(`Redis:Price of ${tokenSymbol} is ${data}`);
-    const priceInfo = JSON.parse(data);
-    priceInfo.timestamp = new Date(priceInfo.timestamp);
-    const isStale = (/* @__PURE__ */ new Date()).getTime() - priceInfo.timestamp.getTime() > STALE_TIME;
-    Global.assert(!isStale, `Price of ${tokenSymbol} is stale`);
-    return priceInfo;
-  }
-};
-
-// src/utils/store.ts
-var import_fs = __toESM(require("fs"));
+// src/strategies/sensei.ts
 var import_starknet10 = require("starknet");
+
+// src/data/sensei.abi.json
+var sensei_abi_default = [
+  {
+    type: "impl",
+    name: "IStrategyCustomImpl",
+    interface_name: "strkfarm::interfaces::ERC721Strategy::IStrategyCustom"
+  },
+  {
+    type: "struct",
+    name: "core::integer::u256",
+    members: [
+      {
+        name: "low",
+        type: "core::integer::u128"
+      },
+      {
+        name: "high",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::interfaces::IEkuboDistributor::Claim",
+    members: [
+      {
+        name: "id",
+        type: "core::integer::u64"
+      },
+      {
+        name: "claimee",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "amount",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::array::Span::<core::felt252>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::felt252>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::components::swap::Route",
+    members: [
+      {
+        name: "token_from",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "token_to",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "exchange_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "percent",
+        type: "core::integer::u128"
+      },
+      {
+        name: "additional_swap_params",
+        type: "core::array::Array::<core::felt252>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::components::swap::AvnuMultiRouteSwap",
+    members: [
+      {
+        name: "token_from_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "token_from_amount",
+        type: "core::integer::u256"
+      },
+      {
+        name: "token_to_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "token_to_amount",
+        type: "core::integer::u256"
+      },
+      {
+        name: "token_to_min_amount",
+        type: "core::integer::u256"
+      },
+      {
+        name: "beneficiary",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "integrator_fee_amount_bps",
+        type: "core::integer::u128"
+      },
+      {
+        name: "integrator_fee_recipient",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "routes",
+        type: "core::array::Array::<strkfarm::components::swap::Route>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::interfaces::ERC721Strategy::Position",
+    members: [
+      {
+        name: "acc1_supply_shares",
+        type: "core::integer::u256"
+      },
+      {
+        name: "acc1_borrow_shares",
+        type: "core::integer::u256"
+      },
+      {
+        name: "acc2_supply_shares",
+        type: "core::integer::u256"
+      },
+      {
+        name: "acc2_borrow_shares",
+        type: "core::integer::u256"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::bool",
+    variants: [
+      {
+        name: "False",
+        type: "()"
+      },
+      {
+        name: "True",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::interfaces::ERC721Strategy::PositionDescription",
+    members: [
+      {
+        name: "estimated_size",
+        type: "core::integer::u256"
+      },
+      {
+        name: "deposit1",
+        type: "core::integer::u256"
+      },
+      {
+        name: "borrow1",
+        type: "core::integer::u256"
+      },
+      {
+        name: "deposit2",
+        type: "core::integer::u256"
+      },
+      {
+        name: "borrow2",
+        type: "core::integer::u256"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::interfaces::oracle::IPriceOracleDispatcher",
+    members: [
+      {
+        name: "contract_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "ekubo::interfaces::core::ICoreDispatcher",
+    members: [
+      {
+        name: "contract_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::components::ekuboSwap::IRouterDispatcher",
+    members: [
+      {
+        name: "contract_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::components::ekuboSwap::EkuboSwapStruct",
+    members: [
+      {
+        name: "core",
+        type: "ekubo::interfaces::core::ICoreDispatcher"
+      },
+      {
+        name: "router",
+        type: "strkfarm::components::ekuboSwap::IRouterDispatcher"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "ekubo::types::keys::PoolKey",
+    members: [
+      {
+        name: "token0",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "token1",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "fee",
+        type: "core::integer::u128"
+      },
+      {
+        name: "tick_spacing",
+        type: "core::integer::u128"
+      },
+      {
+        name: "extension",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "ekubo::interfaces::router::RouteNode",
+    members: [
+      {
+        name: "pool_key",
+        type: "ekubo::types::keys::PoolKey"
+      },
+      {
+        name: "sqrt_ratio_limit",
+        type: "core::integer::u256"
+      },
+      {
+        name: "skip_ahead",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::interfaces::ERC721Strategy::Settings",
+    members: [
+      {
+        name: "base_fee_percent",
+        type: "core::integer::u128"
+      },
+      {
+        name: "reward_fee_percent",
+        type: "core::integer::u128"
+      },
+      {
+        name: "fee_receiver",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "min_health_factor",
+        type: "core::integer::u32"
+      },
+      {
+        name: "target_health_factor",
+        type: "core::integer::u32"
+      },
+      {
+        name: "coefs_sum1",
+        type: "core::integer::u128"
+      },
+      {
+        name: "coefs_sum2",
+        type: "core::integer::u128"
+      },
+      {
+        name: "oracle",
+        type: "strkfarm::interfaces::oracle::IPriceOracleDispatcher"
+      },
+      {
+        name: "ekubo_swap",
+        type: "strkfarm::components::ekuboSwap::EkuboSwapStruct"
+      },
+      {
+        name: "swap_routes1",
+        type: "core::array::Array::<ekubo::interfaces::router::RouteNode>"
+      },
+      {
+        name: "swap_routes2",
+        type: "core::array::Array::<ekubo::interfaces::router::RouteNode>"
+      },
+      {
+        name: "additional_shares_action_id",
+        type: "core::integer::u8"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "strkfarm::interfaces::ERC721Strategy::IStrategyCustom",
+    items: [
+      {
+        type: "function",
+        name: "deposit",
+        inputs: [
+          {
+            name: "amount",
+            type: "core::integer::u256"
+          },
+          {
+            name: "receiver",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "health_factors",
+        inputs: [],
+        outputs: [
+          {
+            type: "(core::integer::u32, core::integer::u32)"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "harvest",
+        inputs: [
+          {
+            name: "protocol1_rewards_contract",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "claim1",
+            type: "strkfarm::interfaces::IEkuboDistributor::Claim"
+          },
+          {
+            name: "proof1",
+            type: "core::array::Span::<core::felt252>"
+          },
+          {
+            name: "protocol2_rewards_contract",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "claim2",
+            type: "strkfarm::interfaces::IEkuboDistributor::Claim"
+          },
+          {
+            name: "proof2",
+            type: "core::array::Span::<core::felt252>"
+          },
+          {
+            name: "swapInfo",
+            type: "strkfarm::components::swap::AvnuMultiRouteSwap"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "withdraw",
+        inputs: [
+          {
+            name: "amount",
+            type: "core::integer::u256"
+          },
+          {
+            name: "receiver",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "max_slippage_bps",
+            type: "core::integer::u32"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "get_all_shares",
+        inputs: [],
+        outputs: [
+          {
+            type: "strkfarm::interfaces::ERC721Strategy::Position"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "rebalance",
+        inputs: [
+          {
+            name: "amount",
+            type: "core::integer::u256"
+          },
+          {
+            name: "shouldRepay",
+            type: "core::bool"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "describe_position",
+        inputs: [
+          {
+            name: "token_id",
+            type: "core::felt252"
+          }
+        ],
+        outputs: [
+          {
+            type: "(strkfarm::interfaces::ERC721Strategy::Position, strkfarm::interfaces::ERC721Strategy::PositionDescription)"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "set_settings",
+        inputs: [
+          {
+            name: "settings",
+            type: "strkfarm::interfaces::ERC721Strategy::Settings"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "initialize",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "MMSettingsImpl",
+    interface_name: "strkfarm::strats::dnmm_vesu::DeltaNeutralLoopingVesuXSTRK::IMMSettings"
+  },
+  {
+    type: "struct",
+    name: "strkfarm::components::endur::EndurSettings",
+    members: [
+      {
+        name: "lst",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::interfaces::IVesu::IStonDispatcher",
+    members: [
+      {
+        name: "contract_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::components::vesu::vesuStruct",
+    members: [
+      {
+        name: "singleton",
+        type: "strkfarm::interfaces::IVesu::IStonDispatcher"
+      },
+      {
+        name: "pool_id",
+        type: "core::felt252"
+      },
+      {
+        name: "debt",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "col",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "oracle",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "strkfarm::strats::dnmm_vesu::DeltaNeutralLoopingVesuXSTRK::IMMSettings",
+    items: [
+      {
+        type: "function",
+        name: "set_mm_settings",
+        inputs: [
+          {
+            name: "lend_settings1",
+            type: "strkfarm::components::endur::EndurSettings"
+          },
+          {
+            name: "lend_settings2",
+            type: "strkfarm::components::vesu::vesuStruct"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "DNMMImpl",
+    interface_name: "strkfarm::interfaces::ERC721Strategy::IStrategy"
+  },
+  {
+    type: "struct",
+    name: "strkfarm::interfaces::ERC721Strategy::StrategyConfig",
+    members: [
+      {
+        name: "main_token",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "main_offset",
+        type: "core::integer::u128"
+      },
+      {
+        name: "secondary_token",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "secondary_offset",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "strkfarm::interfaces::ERC721Strategy::IStrategy",
+    items: [
+      {
+        type: "function",
+        name: "config",
+        inputs: [],
+        outputs: [
+          {
+            type: "strkfarm::interfaces::ERC721Strategy::StrategyConfig"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_settings",
+        inputs: [],
+        outputs: [
+          {
+            type: "strkfarm::interfaces::ERC721Strategy::Settings"
+          }
+        ],
+        state_mutability: "view"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "EkuboLockedImpl",
+    interface_name: "ekubo::interfaces::core::ILocker"
+  },
+  {
+    type: "interface",
+    name: "ekubo::interfaces::core::ILocker",
+    items: [
+      {
+        type: "function",
+        name: "locked",
+        inputs: [
+          {
+            name: "id",
+            type: "core::integer::u32"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "ERC721MixinImpl",
+    interface_name: "openzeppelin_token::erc721::interface::ERC721ABI"
+  },
+  {
+    type: "struct",
+    name: "core::byte_array::ByteArray",
+    members: [
+      {
+        name: "data",
+        type: "core::array::Array::<core::bytes_31::bytes31>"
+      },
+      {
+        name: "pending_word",
+        type: "core::felt252"
+      },
+      {
+        name: "pending_word_len",
+        type: "core::integer::u32"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "openzeppelin_token::erc721::interface::ERC721ABI",
+    items: [
+      {
+        type: "function",
+        name: "balance_of",
+        inputs: [
+          {
+            name: "account",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "owner_of",
+        inputs: [
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "safe_transfer_from",
+        inputs: [
+          {
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "transfer_from",
+        inputs: [
+          {
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "approve",
+        inputs: [
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "set_approval_for_all",
+        inputs: [
+          {
+            name: "operator",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "approved",
+            type: "core::bool"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "get_approved",
+        inputs: [
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "is_approved_for_all",
+        inputs: [
+          {
+            name: "owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "operator",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "supports_interface",
+        inputs: [
+          {
+            name: "interface_id",
+            type: "core::felt252"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "name",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::byte_array::ByteArray"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "symbol",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::byte_array::ByteArray"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "token_uri",
+        inputs: [
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::byte_array::ByteArray"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "balanceOf",
+        inputs: [
+          {
+            name: "account",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "ownerOf",
+        inputs: [
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "safeTransferFrom",
+        inputs: [
+          {
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "transferFrom",
+        inputs: [
+          {
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "setApprovalForAll",
+        inputs: [
+          {
+            name: "operator",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "approved",
+            type: "core::bool"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "getApproved",
+        inputs: [
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "isApprovedForAll",
+        inputs: [
+          {
+            name: "owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "operator",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tokenURI",
+        inputs: [
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::byte_array::ByteArray"
+          }
+        ],
+        state_mutability: "view"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "RewardShareImpl",
+    interface_name: "strkfarm::components::harvester::reward_shares::IRewardShare"
+  },
+  {
+    type: "struct",
+    name: "strkfarm::components::harvester::reward_shares::UserRewardsInfo",
+    members: [
+      {
+        name: "pending_round_points",
+        type: "core::felt252"
+      },
+      {
+        name: "shares_owned",
+        type: "core::felt252"
+      },
+      {
+        name: "block_number",
+        type: "core::integer::u64"
+      },
+      {
+        name: "index",
+        type: "core::integer::u32"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm::components::harvester::reward_shares::RewardsInfo",
+    members: [
+      {
+        name: "amount",
+        type: "core::felt252"
+      },
+      {
+        name: "shares",
+        type: "core::felt252"
+      },
+      {
+        name: "total_round_points",
+        type: "core::felt252"
+      },
+      {
+        name: "block_number",
+        type: "core::integer::u64"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "strkfarm::components::harvester::reward_shares::IRewardShare",
+    items: [
+      {
+        type: "function",
+        name: "get_user_reward_info",
+        inputs: [
+          {
+            name: "user",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "strkfarm::components::harvester::reward_shares::UserRewardsInfo"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_rewards_info",
+        inputs: [
+          {
+            name: "index",
+            type: "core::integer::u32"
+          }
+        ],
+        outputs: [
+          {
+            type: "strkfarm::components::harvester::reward_shares::RewardsInfo"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_total_rewards",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u32"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_total_unminted_shares",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::felt252"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_additional_shares",
+        inputs: [
+          {
+            name: "user",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "(core::felt252, core::integer::u64, core::felt252)"
+          }
+        ],
+        state_mutability: "view"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "CommonCompImpl",
+    interface_name: "strkfarm::interfaces::common::ICommon"
+  },
+  {
+    type: "interface",
+    name: "strkfarm::interfaces::common::ICommon",
+    items: [
+      {
+        type: "function",
+        name: "upgrade",
+        inputs: [
+          {
+            name: "new_class",
+            type: "core::starknet::class_hash::ClassHash"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "pause",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "unpause",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "is_paused",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "owner",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "transfer_ownership",
+        inputs: [
+          {
+            name: "new_owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "renounce_ownership",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "constructor",
+    name: "constructor",
+    inputs: [
+      {
+        name: "name",
+        type: "core::byte_array::ByteArray"
+      },
+      {
+        name: "symbol",
+        type: "core::byte_array::ByteArray"
+      },
+      {
+        name: "base_uri",
+        type: "core::byte_array::ByteArray"
+      },
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "main_token",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "main_offset",
+        type: "core::integer::u128"
+      },
+      {
+        name: "secondary_token",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "secondary_offset",
+        type: "core::integer::u128"
+      },
+      {
+        name: "settings",
+        type: "strkfarm::interfaces::ERC721Strategy::Settings"
+      },
+      {
+        name: "lend_settings1",
+        type: "strkfarm::components::endur::EndurSettings"
+      },
+      {
+        name: "lend_settings2",
+        type: "strkfarm::components::vesu::vesuStruct"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::Transfer",
+    kind: "struct",
+    members: [
+      {
+        name: "from",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "to",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "token_id",
+        type: "core::integer::u256",
+        kind: "key"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::Approval",
+    kind: "struct",
+    members: [
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "approved",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "token_id",
+        type: "core::integer::u256",
+        kind: "key"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::ApprovalForAll",
+    kind: "struct",
+    members: [
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "operator",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "approved",
+        type: "core::bool",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Transfer",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::Transfer",
+        kind: "nested"
+      },
+      {
+        name: "Approval",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::Approval",
+        kind: "nested"
+      },
+      {
+        name: "ApprovalForAll",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::ApprovalForAll",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_introspection::src5::SRC5Component::Event",
+    kind: "enum",
+    variants: []
+  },
+  {
+    type: "event",
+    name: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Upgraded",
+    kind: "struct",
+    members: [
+      {
+        name: "class_hash",
+        type: "core::starknet::class_hash::ClassHash",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Upgraded",
+        type: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Upgraded",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_security::pausable::PausableComponent::Paused",
+    kind: "struct",
+    members: [
+      {
+        name: "account",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_security::pausable::PausableComponent::Unpaused",
+    kind: "struct",
+    members: [
+      {
+        name: "account",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_security::pausable::PausableComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Paused",
+        type: "openzeppelin_security::pausable::PausableComponent::Paused",
+        kind: "nested"
+      },
+      {
+        name: "Unpaused",
+        type: "openzeppelin_security::pausable::PausableComponent::Unpaused",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_security::reentrancyguard::ReentrancyGuardComponent::Event",
+    kind: "enum",
+    variants: []
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::ownable::ownable::OwnableComponent::OwnershipTransferred",
+    kind: "struct",
+    members: [
+      {
+        name: "previous_owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "new_owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::ownable::ownable::OwnableComponent::OwnershipTransferStarted",
+    kind: "struct",
+    members: [
+      {
+        name: "previous_owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "new_owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::ownable::ownable::OwnableComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "OwnershipTransferred",
+        type: "openzeppelin_access::ownable::ownable::OwnableComponent::OwnershipTransferred",
+        kind: "nested"
+      },
+      {
+        name: "OwnershipTransferStarted",
+        type: "openzeppelin_access::ownable::ownable::OwnableComponent::OwnershipTransferStarted",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm::components::common::CommonComp::Event",
+    kind: "enum",
+    variants: []
+  },
+  {
+    type: "event",
+    name: "strkfarm::components::harvester::reward_shares::RewardShareComponent::Rewards",
+    kind: "struct",
+    members: [
+      {
+        name: "index",
+        type: "core::integer::u32",
+        kind: "data"
+      },
+      {
+        name: "info",
+        type: "strkfarm::components::harvester::reward_shares::RewardsInfo",
+        kind: "data"
+      },
+      {
+        name: "total_reward_shares",
+        type: "core::felt252",
+        kind: "data"
+      },
+      {
+        name: "timestamp",
+        type: "core::integer::u64",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm::components::harvester::reward_shares::RewardShareComponent::UserRewards",
+    kind: "struct",
+    members: [
+      {
+        name: "user",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "info",
+        type: "strkfarm::components::harvester::reward_shares::UserRewardsInfo",
+        kind: "data"
+      },
+      {
+        name: "total_reward_shares",
+        type: "core::felt252",
+        kind: "data"
+      },
+      {
+        name: "timestamp",
+        type: "core::integer::u64",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm::components::harvester::reward_shares::RewardShareComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Rewards",
+        type: "strkfarm::components::harvester::reward_shares::RewardShareComponent::Rewards",
+        kind: "nested"
+      },
+      {
+        name: "UserRewards",
+        type: "strkfarm::components::harvester::reward_shares::RewardShareComponent::UserRewards",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::Deposit",
+    kind: "struct",
+    members: [
+      {
+        name: "sender",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "assets",
+        type: "core::integer::u256",
+        kind: "data"
+      },
+      {
+        name: "net_position",
+        type: "strkfarm::interfaces::ERC721Strategy::Position",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::Withdraw",
+    kind: "struct",
+    members: [
+      {
+        name: "sender",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "receiver",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "assets",
+        type: "core::integer::u256",
+        kind: "data"
+      },
+      {
+        name: "net_position",
+        type: "strkfarm::interfaces::ERC721Strategy::Position",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::Rebalance",
+    kind: "struct",
+    members: [
+      {
+        name: "caller",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "amount",
+        type: "core::integer::u256",
+        kind: "data"
+      },
+      {
+        name: "shouldRepay",
+        type: "core::bool",
+        kind: "data"
+      },
+      {
+        name: "pre_hf1",
+        type: "core::integer::u32",
+        kind: "data"
+      },
+      {
+        name: "pre_hf2",
+        type: "core::integer::u32",
+        kind: "data"
+      },
+      {
+        name: "hf1",
+        type: "core::integer::u32",
+        kind: "data"
+      },
+      {
+        name: "hf2",
+        type: "core::integer::u32",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::ShareUpdate",
+    kind: "struct",
+    members: [
+      {
+        name: "token_id",
+        type: "core::felt252",
+        kind: "key"
+      },
+      {
+        name: "action_id",
+        type: "core::integer::u8",
+        kind: "key"
+      },
+      {
+        name: "user_shares",
+        type: "core::felt252",
+        kind: "data"
+      },
+      {
+        name: "total_shares",
+        type: "core::felt252",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Deposit",
+        type: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::Deposit",
+        kind: "nested"
+      },
+      {
+        name: "Withdraw",
+        type: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::Withdraw",
+        kind: "nested"
+      },
+      {
+        name: "Rebalance",
+        type: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::Rebalance",
+        kind: "nested"
+      },
+      {
+        name: "ShareUpdate",
+        type: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::ShareUpdate",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm::strats::dnmm_vesu::DeltaNeutralLoopingVesuXSTRK::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "ERC721Event",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::Event",
+        kind: "flat"
+      },
+      {
+        name: "SRC5Event",
+        type: "openzeppelin_introspection::src5::SRC5Component::Event",
+        kind: "flat"
+      },
+      {
+        name: "UpgradeableEvent",
+        type: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Event",
+        kind: "flat"
+      },
+      {
+        name: "PausableEvent",
+        type: "openzeppelin_security::pausable::PausableComponent::Event",
+        kind: "flat"
+      },
+      {
+        name: "ReentrancyGuardEvent",
+        type: "openzeppelin_security::reentrancyguard::ReentrancyGuardComponent::Event",
+        kind: "flat"
+      },
+      {
+        name: "OwnableEvent",
+        type: "openzeppelin_access::ownable::ownable::OwnableComponent::Event",
+        kind: "flat"
+      },
+      {
+        name: "CommonCompEvent",
+        type: "strkfarm::components::common::CommonComp::Event",
+        kind: "flat"
+      },
+      {
+        name: "RewardShareEvent",
+        type: "strkfarm::components::harvester::reward_shares::RewardShareComponent::Event",
+        kind: "flat"
+      },
+      {
+        name: "DeltaNeutralLoopingEvent",
+        type: "strkfarm::components::delta_neutral_component::DeltaNeutralLoopingCom::Event",
+        kind: "flat"
+      }
+    ]
+  }
+];
+
+// src/strategies/sensei.ts
+var SenseiVault = class extends BaseStrategy {
+  constructor(config, pricer, metadata) {
+    super(config);
+    this.getSettings = async () => {
+      const settings = await this.contract.call("get_settings", []);
+      logger.verbose("getSettings", settings);
+      return settings;
+    };
+    this.address = metadata.address;
+    this.pricer = pricer;
+    this.metadata = metadata;
+    this.contract = new import_starknet10.Contract(sensei_abi_default, this.address.address, this.config.provider);
+    if (metadata.depositTokens.length === 0) {
+      throw new Error("Deposit tokens are not defined in metadata");
+    }
+  }
+  async getUserTVL(user) {
+    const result = await this.contract.call(
+      "describe_position",
+      [user.address]
+    );
+    const amount = Web3Number.fromWei(
+      import_starknet10.uint256.uint256ToBN(result[1].estimated_size).toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    const price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol
+    );
+    return {
+      usdValue: Number(amount.toFixed(6)) * price.price,
+      amount,
+      tokenInfo: this.metadata.depositTokens[0]
+    };
+  }
+  async getTVL() {
+    try {
+      const {
+        collateralXSTRK,
+        collateralUSDValue,
+        debtSTRK,
+        debtUSDValue,
+        xSTRKPrice,
+        collateralInSTRK
+      } = await this.getPositionInfo();
+      const usdValue = Number(collateralUSDValue.toFixed(6)) - Number(debtUSDValue.toFixed(6));
+      return {
+        usdValue,
+        amount: new Web3Number(
+          (collateralInSTRK - Number(debtSTRK.toFixed(6))).toFixed(6),
+          collateralXSTRK.decimals
+        ),
+        tokenInfo: this.metadata.depositTokens[0]
+      };
+    } catch (error) {
+      console.error("Error fetching TVL:", error);
+      return {
+        usdValue: 0,
+        amount: new Web3Number("0", this.metadata.depositTokens[0].decimals),
+        tokenInfo: this.metadata.depositTokens[0]
+      };
+    }
+  }
+  async depositCall(amountInfo, receiver) {
+    const mainTokenContract = new import_starknet10.Contract(
+      erc20_abi_default,
+      this.metadata.depositTokens[0].address.address,
+      this.config.provider
+    );
+    const call1 = mainTokenContract.populate("approve", [
+      this.address.address,
+      import_starknet10.uint256.bnToUint256(amountInfo.amount.toWei())
+    ]);
+    const call2 = this.contract.populate("deposit", [
+      import_starknet10.uint256.bnToUint256(amountInfo.amount.toWei()),
+      receiver.address
+    ]);
+    const calls = [call1, call2];
+    return calls;
+  }
+  async withdrawCall(amountInfo, receiver, owner) {
+    const call = this.contract.populate("withdraw", [
+      import_starknet10.uint256.bnToUint256(amountInfo.amount.toWei()),
+      receiver.address,
+      300
+      // 3% max slippage
+    ]);
+    return [call];
+  }
+  async getPositionInfo() {
+    const CACHE_KEY = "positionInfo";
+    if (this.isCacheValid(CACHE_KEY)) {
+      return this.getCache(CACHE_KEY);
+    }
+    const resp = await fetch(
+      `${getTrovesEndpoint()}/vesu/positions?walletAddress=${this.address.address}`
+    );
+    const data = await resp.json();
+    if (!data.data || data.data.length == 0) {
+      throw new Error("No positions found");
+    }
+    const collateralXSTRK = Web3Number.fromWei(
+      data.data[0].collateral.value,
+      data.data[0].collateral.decimals
+    );
+    const collateralUSDValue = Web3Number.fromWei(
+      data.data[0].collateral.usdPrice.value,
+      data.data[0].collateral.usdPrice.decimals
+    );
+    const debtSTRK = Web3Number.fromWei(
+      data.data[0].debt.value,
+      data.data[0].debt.decimals
+    );
+    const debtUSDValue = Web3Number.fromWei(
+      data.data[0].debt.usdPrice.value,
+      data.data[0].debt.usdPrice.decimals
+    );
+    const xSTRKPrice = await this.getSecondaryTokenPriceRelativeToMain();
+    const collateralInSTRK = Number(collateralXSTRK.toFixed(6)) * xSTRKPrice;
+    const STRKUSDPrice = Number(debtUSDValue.toFixed(6)) / Number(debtSTRK.toFixed(6));
+    const actualCollateralUSDValue = collateralInSTRK * STRKUSDPrice;
+    const cacheData = {
+      collateralXSTRK,
+      collateralUSDValue: new Web3Number(
+        actualCollateralUSDValue.toFixed(6),
+        collateralUSDValue.decimals
+      ),
+      debtSTRK,
+      debtUSDValue,
+      xSTRKPrice,
+      collateralInSTRK
+    };
+    this.setCache(CACHE_KEY, cacheData);
+    return cacheData;
+  }
+  async getSecondaryTokenPriceRelativeToMain(retry = 0) {
+    const CACHE_KEY = "xSTRKPrice";
+    if (this.isCacheValid(CACHE_KEY)) {
+      return this.getCache(CACHE_KEY);
+    }
+    const params = {
+      sellTokenAddress: this.metadata.additionalInfo.secondaryToken.address.address,
+      buyTokenAddress: this.metadata.additionalInfo.mainToken.address.address,
+      sellAmount: BigInt(new Web3Number("1", 18).toWei()),
+      takerAddress: this.address.address
+    };
+    logger.verbose("getSecondaryTokenPriceRelativeToMain [1]", params);
+    let avnu = new AvnuWrapper();
+    const quote = await avnu.getQuotes(
+      params.sellTokenAddress,
+      params.buyTokenAddress,
+      params.sellAmount?.toString() || "0",
+      params.takerAddress
+    );
+    if (!quote) {
+      throw new Error("No quotes found to compute secondary token price relative to main token");
+    }
+    const firstQuote = quote;
+    const price = Number(
+      Web3Number.fromWei(firstQuote.buyAmount.toString(), 18).toFixed(
+        6
+      )
+    );
+    logger.verbose("getSecondaryTokenPriceRelativeToMain [2]", price);
+    this.setCache(CACHE_KEY, price);
+    return price;
+  }
+};
+var senseiDescription = `Deposit your {{token1}} to automatically loop your funds via Endur ({{token2}}) and Vesu to create a delta neutral position. This strategy is designed to maximize your yield on {{token1}}. Your position is automatically adjusted periodically to maintain a healthy health factor. You receive a NFT as representation for your stake on Troves. You can withdraw anytime by redeeming your NFT for {{token1}}.`;
+var vesuProtocol = {
+  name: "Vesu",
+  logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"
+};
+var endurProtocol = {
+  name: "Endur",
+  logo: "https://app.endur.fi/logo.png"
+};
+var _riskFactor3 = [
+  { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 0.5, weight: 25, reason: "Audited by CSC" },
+  { type: "Depeg Risk" /* DEPEG_RISK */, value: 0.25, weight: 25, reason: "Depending on prevailing market conditions and trading activity, xSTRK may lose its peg to the underlying asset." },
+  { type: "Liquidation Risk" /* LIQUIDATION_RISK */, value: 0.1, weight: 10, reason: "Liquidation risk is low due to the nature of the Re7 Pool on Vesu" },
+  { type: "Low Liquidity Risk" /* LOW_LIQUIDITY_RISK */, value: 0.5, weight: 50, reason: "xSTRK can be sometimes illiquid near true price" }
+];
+var FAQS = [
+  {
+    question: "What is xSTRK Sensei?",
+    answer: "xSTRK Sensei is a leveraged looping strategy involving xSTRK and STRK. It uses xSTRK as collateral on Vesu, borrows STRK, and buys more xSTRK with it to create up to 4x leverage and boost yields."
+  },
+  {
+    question: "What is the benefit of using xSTRK Sensei?",
+    answer: "The strategy amplifies your xSTRK exposure and yield through leverage. It also helps you accumulate more Endur points faster."
+  },
+  {
+    question: "What is the maximum leverage possible?",
+    answer: "The strategy may allow up to ~4x leverage, depending on your collateral ratio and market conditions on Vesu. This strategy tries to maintain a health factor of 1.1 on Vesu"
+  },
+  {
+    question: "Isn't 1.1 health factor risky?",
+    answer: "Based on Re7's xSTRK pool configuration on Vesu, xSTRK uses STRK price as its oracle source. This means collateral and debt will always move in the same direction, making 1.1 HF safe. However, if debt increases too much (over months), liquidation may occur, which we try to avoid by actively monitoring the position."
+  },
+  {
+    question: "Are there any risks involved?",
+    answer: "Yes. The major risks are related to xSTRK's illiquidity and price volatility. During volatility or low liquidity, exiting a position can result in loss."
+  },
+  {
+    question: "Does the position always grow?",
+    answer: "No. While xSTRK's true value increases over time, its DEX price may not grow continuously and can fluctuate or move in discrete steps."
+  },
+  {
+    question: "Can I lose money using this strategy?",
+    answer: "Yes. If the xSTRK price drops sharply or becomes illiquid, you may face slippage or loss when trying to exit the looped position."
+  },
+  {
+    question: "What affects the DEX price of xSTRK?",
+    answer: "xSTRK's DEX price depends on supply, demand, and liquidity. Unlike its true value which grows steadily, the DEX price can fluctuate due to market activity."
+  },
+  {
+    question: "Why is xSTRK considered illiquid?",
+    answer: "Since xSTRK is a evolving LST with limited trading volume, sudden large trades can cause high slippage, making it harder to enter or exit positions efficiently. Such conditions normalize over time. Enter and exit positions with caution."
+  },
+  {
+    question: "Do I earn Endur points on looped xSTRK?",
+    answer: "Yes. All xSTRK in the looped position contributes to your Endur points, allowing you to farm points more effectively with leverage. Visit endur.fi/leaderboard to see your points."
+  }
+];
+var SenseiStrategies = [
+  {
+    name: "xSTRK Sensei",
+    description: highlightTextWithLinks(
+      senseiDescription.replaceAll("{{token1}}", "STRK").replaceAll("{{token2}}", "xSTRK"),
+      [{
+        highlight: "Endur",
+        link: "https://endur.fi"
+      }, {
+        highlight: "Vesu",
+        link: "https://vesu.xyz"
+      }, {
+        highlight: "delta neutral position",
+        link: "https://www.investopedia.com/terms/d/deltaneutral.asp"
+      }]
+    ),
+    address: ContractAddr.from(
+      "0x7023a5cadc8a5db80e4f0fde6b330cbd3c17bbbf9cb145cbabd7bd5e6fb7b0b"
+    ),
+    launchBlock: 1053811,
+    type: "Other",
+    depositTokens: [
+      Global.getDefaultTokens().find((t) => t.symbol === "STRK")
+    ],
+    protocols: [endurProtocol, vesuProtocol],
+    maxTVL: new Web3Number("1500000", 18),
+    risk: {
+      riskFactor: _riskFactor3,
+      netRisk: _riskFactor3.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor3.reduce((acc, curr) => acc + curr.weight, 0),
+      notARisks: getNoRiskTags(_riskFactor3)
+    },
+    additionalInfo: {
+      mainToken: Global.getDefaultTokens().find((t) => t.symbol === "STRK"),
+      secondaryToken: Global.getDefaultTokens().find((t) => t.symbol === "xSTRK"),
+      targetHfBps: 11e3,
+      // 1.1 health factor
+      feeBps: 2e3
+      // 2% fee on profits
+    },
+    faqs: FAQS,
+    contractDetails: [],
+    investmentSteps: [
+      "Swap STRK for xSTRK",
+      "Deposit xSTRK to Vesu's Re7 xSTRK Pool",
+      "Borrow STRK against your xSTRK collateral",
+      "Buy more xSTRK with borrowed STRK",
+      "Repeat the process to loop your position",
+      "Claim DeFi spring (STRK) rewards weekly and reinvest"
+    ]
+  }
+];
+
+// src/notifs/telegram.ts
+var import_node_telegram_bot_api = __toESM(require("node-telegram-bot-api"));
+var TelegramNotif = class {
+  constructor(token, shouldPoll) {
+    this.subscribers = [
+      // '6820228303',
+      "1505578076",
+      // '5434736198', // maaza
+      "1356705582",
+      // langs
+      "1388729514",
+      // hwashere
+      "6020162572",
+      //minato
+      "985902592"
+    ];
+    this.bot = new import_node_telegram_bot_api.default(token, { polling: shouldPoll });
+  }
+  // listen to start msgs, register chatId and send registered msg
+  activateChatBot() {
+    this.bot.on("message", (msg) => {
+      const chatId = msg.chat.id;
+      let text = msg.text.toLowerCase().trim();
+      logger.verbose(`Tg: IncomingMsg: ID: ${chatId}, msg: ${text}`);
+      if (text == "start") {
+        this.bot.sendMessage(chatId, "Registered");
+        this.subscribers.push(chatId);
+        logger.verbose(`Tg: New subscriber: ${chatId}`);
+      } else {
+        this.bot.sendMessage(chatId, "Unrecognized command. Supported commands: start");
+      }
+    });
+  }
+  // send a given msg to all registered users
+  sendMessage(msg) {
+    logger.verbose(`Tg: Sending message: ${msg}`);
+    for (let chatId of this.subscribers) {
+      this.bot.sendMessage(chatId, msg).catch((err) => {
+        logger.error(`Tg: Error sending msg to ${chatId}`);
+        logger.error(`Tg: Error sending message: ${err.message}`);
+      }).then(() => {
+        logger.verbose(`Tg: Message sent to ${chatId}`);
+      });
+    }
+  }
+};
+
+// src/node/pricer-redis.ts
+var import_redis = require("redis");
+var PricerRedis = class extends Pricer {
+  constructor(config, tokens2) {
+    super(config, tokens2);
+    this.redisClient = null;
+  }
+  /** Reads prices from Pricer._loadPrices and uses a callback to set prices in redis */
+  async startWithRedis(redisUrl) {
+    await this.initRedis(redisUrl);
+    logger.info(`Starting Pricer with Redis`);
+    this._loadPrices(this._setRedisPrices.bind(this));
+    setInterval(() => {
+      this._loadPrices(this._setRedisPrices.bind(this));
+    }, 3e4);
+  }
+  async close() {
+    if (this.redisClient) {
+      await this.redisClient.disconnect();
+    }
+  }
+  async initRedis(redisUrl) {
+    logger.info(`Initialising Redis Client`);
+    this.redisClient = await (0, import_redis.createClient)({
+      url: redisUrl
+    });
+    this.redisClient.on("error", (err) => console.log("Redis Client Error", err)).connect();
+    logger.info(`Redis Client Initialised`);
+  }
+  /** sets current local price in redis */
+  _setRedisPrices(tokenSymbol) {
+    if (!this.redisClient) {
+      throw new FatalError(`Redis client not initialised`);
+    }
+    this.redisClient.set(`Price:${tokenSymbol}`, JSON.stringify(this.prices[tokenSymbol])).catch((err) => {
+      logger.warn(`Error setting price in redis for ${tokenSymbol}`);
+    });
+  }
+  /** Returns price from redis */
+  async getPrice(tokenSymbol) {
+    const STALE_TIME = 6e4;
+    if (!this.redisClient) {
+      throw new FatalError(`Redis client not initialised`);
+    }
+    const data = await this.redisClient.get(`Price:${tokenSymbol}`);
+    if (!data) {
+      throw new FatalError(`Redis:Price of ${tokenSymbol} not found`);
+    }
+    logger.verbose(`Redis:Price of ${tokenSymbol} is ${data}`);
+    const priceInfo = JSON.parse(data);
+    priceInfo.timestamp = new Date(priceInfo.timestamp);
+    const isStale = (/* @__PURE__ */ new Date()).getTime() - priceInfo.timestamp.getTime() > STALE_TIME;
+    Global.assert(!isStale, `Price of ${tokenSymbol} is stale`);
+    return priceInfo;
+  }
+};
+
+// src/utils/store.ts
+var import_fs = __toESM(require("fs"));
+var import_starknet11 = require("starknet");
 var crypto2 = __toESM(require("crypto"));
 
 // src/utils/encrypt.ts
@@ -16535,7 +18628,7 @@ var Store = class _Store {
     logger.warn(`This not stored anywhere, please you backup this password for future use`);
     logger.warn(`\u26A0\uFE0F=========================================\u26A0\uFE0F`);
   }
-  getAccount(accountKey, txVersion = import_starknet10.constants.TRANSACTION_VERSION.V2) {
+  getAccount(accountKey, txVersion = import_starknet11.constants.TRANSACTION_VERSION.V2) {
     const accounts = this.loadAccounts();
     logger.verbose(`nAccounts loaded for network: ${Object.keys(accounts).length}`);
     const data = accounts[accountKey];
@@ -16544,7 +18637,7 @@ var Store = class _Store {
     }
     logger.verbose(`Account loaded: ${accountKey} from network: ${this.config.network}`);
     logger.verbose(`Address: ${data.address}`);
-    const acc = new import_starknet10.Account(this.config.provider, data.address, data.pk, void 0, txVersion);
+    const acc = new import_starknet11.Account(this.config.provider, data.address, data.pk, void 0, txVersion);
     return acc;
   }
   addAccount(accountKey, address, pk) {
@@ -16627,6 +18720,8 @@ var Store = class _Store {
   PricerFromApi,
   PricerRedis,
   RiskType,
+  SenseiStrategies,
+  SenseiVault,
   Store,
   TelegramNotif,
   VesuRebalance,
@@ -16640,6 +18735,7 @@ var Store = class _Store {
   getNoRiskTags,
   getRiskColor,
   getRiskExplaination,
+  getTrovesEndpoint,
   highlightTextWithLinks,
   logger
 });