@strkfarm/sdk 1.0.15 → 1.0.17

package/dist/index.js

@@ -41,11 +41,16 @@ __export(src_exports, {
   PasswordJsonCryptoUtil: () => PasswordJsonCryptoUtil,
   Pragma: () => Pragma,
   Pricer: () => Pricer,
+  PricerFromApi: () => PricerFromApi,
   PricerRedis: () => PricerRedis,
+  RiskType: () => RiskType,
   Store: () => Store,
   TelegramNotif: () => TelegramNotif,
+  VesuRebalance: () => VesuRebalance,
+  VesuRebalanceStrategies: () => VesuRebalanceStrategies,
   Web3Number: () => Web3Number,
   ZkLend: () => ZkLend,
+  assert: () => assert,
   getDefaultStoreConfig: () => getDefaultStoreConfig,
   getMainnetConfig: () => getMainnetConfig,
   logger: () => logger
@@ -72,7 +77,14 @@ var FatalError = class extends Error {
     this.name = "FatalError";
   }
 };
-var tokens = [];
+var tokens = [{
+  name: "Starknet",
+  symbol: "STRK",
+  logo: "https://assets.coingecko.com/coins/images/26433/small/starknet.png",
+  address: "0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
+  decimals: 18,
+  coingeckId: "starknet"
+}];
 var Global = class {
   static fatalError(message, err) {
     logger.error(message);
@@ -85,6 +97,9 @@ var Global = class {
     logger.error(`${url}: ${message}`);
     console.error(err);
   }
+  static getDefaultTokens() {
+    return tokens;
+  }
   static async getTokens() {
     if (tokens.length) return tokens;
     const data = await import_axios.default.get("https://starknet.api.avnu.fi/v1/starknet/tokens");
@@ -98,6 +113,7 @@ var Global = class {
         symbol: token.symbol,
         address: token.address,
         decimals: token.decimals,
+        logo: token.logoUri,
         coingeckId: token.extensions.coingeckoId
       });
     });
@@ -126,10 +142,12 @@ var Web3Number = class _Web3Number extends import_bignumber.default {
     return this.mul(10 ** this.decimals).toFixed(0);
   }
   multipliedBy(value) {
-    return new _Web3Number(this.mul(value).toString(), this.decimals);
+    let _value = Number(value).toFixed(6);
+    return new _Web3Number(this.mul(_value).toString(), this.decimals);
   }
   dividedBy(value) {
-    return new _Web3Number(this.div(value).toString(), this.decimals);
+    let _value = Number(value).toFixed(6);
+    return new _Web3Number(this.div(_value).toString(), this.decimals);
   }
   plus(value) {
     return new _Web3Number(this.add(value).toString(), this.decimals);
@@ -175,11 +193,22 @@ var ContractAddr = class _ContractAddr {
   }
 };
 
+// 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");
+  }
+};
+
 // src/modules/pricer.ts
-var CoinMarketCap = require("coinmarketcap-api");
-var Pricer = class {
+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
@@ -189,11 +218,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;
@@ -235,10 +259,10 @@ var Pricer = class {
   assertNotStale(timestamp, tokenName) {
     Global.assert(!this.isStale(timestamp, tokenName), `Price of ${tokenName} is stale`);
   }
-  async getPrice(tokenName) {
-    Global.assert(this.prices[tokenName], `Price of ${tokenName} not found`);
-    this.assertNotStale(this.prices[tokenName].timestamp, tokenName);
-    return this.prices[tokenName];
+  async getPrice(tokenSymbol) {
+    Global.assert(this.prices[tokenSymbol], `Price of ${tokenSymbol} not found`);
+    this.assertNotStale(this.prices[tokenSymbol].timestamp, tokenSymbol);
+    return this.prices[tokenSymbol];
   }
   _loadPrices(onUpdate = () => {
   }) {
@@ -325,10 +349,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());
@@ -522,6 +543,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
@@ -631,8 +653,72 @@ 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";
@@ -728,235 +814,1883 @@ var AutoCompounderSTRK = class {
   }
 };
 
-// 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/utils/store.ts
-var import_fs = __toESM(require("fs"));
+// src/strategies/vesu-rebalance.ts
 var import_starknet5 = require("starknet");
-var crypto2 = __toESM(require("crypto"));
-
-// src/utils/encrypt.ts
-var crypto = __toESM(require("crypto"));
-var PasswordJsonCryptoUtil = class {
-  constructor() {
-    this.algorithm = "aes-256-gcm";
-    this.keyLength = 32;
-    // 256 bits
-    this.saltLength = 16;
-    // 128 bits
-    this.ivLength = 12;
-    // 96 bits for GCM
-    this.tagLength = 16;
-    // 128 bits
-    this.pbkdf2Iterations = 1e5;
-  }
-  // Number of iterations for PBKDF2
-  deriveKey(password, salt) {
-    return crypto.pbkdf2Sync(password, salt, this.pbkdf2Iterations, this.keyLength, "sha256");
-  }
-  encrypt(data, password) {
-    const jsonString = JSON.stringify(data);
-    const salt = crypto.randomBytes(this.saltLength);
-    const iv = crypto.randomBytes(this.ivLength);
-    const key = this.deriveKey(password, salt);
-    const cipher = crypto.createCipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
-    let encrypted = cipher.update(jsonString, "utf8", "hex");
-    encrypted += cipher.final("hex");
-    const tag = cipher.getAuthTag();
-    return Buffer.concat([salt, iv, tag, Buffer.from(encrypted, "hex")]).toString("base64");
-  }
-  decrypt(encryptedData, password) {
-    const data = Buffer.from(encryptedData, "base64");
-    const salt = data.subarray(0, this.saltLength);
-    const iv = data.subarray(this.saltLength, this.saltLength + this.ivLength);
-    const tag = data.subarray(this.saltLength + this.ivLength, this.saltLength + this.ivLength + this.tagLength);
-    const encrypted = data.subarray(this.saltLength + this.ivLength + this.tagLength);
-    const key = this.deriveKey(password, salt);
-    const decipher = crypto.createDecipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
-    decipher.setAuthTag(tag);
-    try {
-      let decrypted = decipher.update(encrypted.toString("hex"), "hex", "utf8");
-      decrypted += decipher.final("utf8");
-      return JSON.parse(decrypted);
-    } catch (error) {
-      throw new Error("Decryption failed. This could be due to an incorrect password or corrupted data.");
-    }
-  }
-};
-
-// src/utils/store.ts
-function getDefaultStoreConfig(network) {
-  if (!process.env.HOME) {
-    throw new Error("StoreConfig: HOME environment variable not found");
-  }
-  return {
-    SECRET_FILE_FOLDER: `${process.env.HOME}/.starknet-store`,
-    NETWORK: network,
-    ACCOUNTS_FILE_NAME: "accounts.json",
-    PASSWORD: crypto2.randomBytes(16).toString("hex")
-  };
-}
-var Store = class _Store {
-  constructor(config, storeConfig) {
-    this.encryptor = new PasswordJsonCryptoUtil();
-    this.config = config;
-    const defaultStoreConfig = getDefaultStoreConfig(config.network);
-    if (!storeConfig.PASSWORD) {
-      _Store.logPassword(defaultStoreConfig.PASSWORD);
-    }
-    this.storeConfig = {
-      ...defaultStoreConfig,
-      ...storeConfig
-    };
-    _Store.ensureFolder(this.storeConfig.SECRET_FILE_FOLDER);
-  }
-  static logPassword(password) {
-    logger.warn(`\u26A0\uFE0F=========================================\u26A0\uFE0F`);
-    logger.warn(`Generated a random password for store`);
-    logger.warn(`\u26A0\uFE0F Password: ${password}`);
-    logger.warn(`This not stored anywhere, please you backup this password for future use`);
-    logger.warn(`\u26A0\uFE0F=========================================\u26A0\uFE0F`);
-  }
-  getAccount(accountKey, txVersion = import_starknet5.constants.TRANSACTION_VERSION.V2) {
-    const accounts = this.loadAccounts();
-    logger.verbose(`nAccounts loaded for network: ${Object.keys(accounts).length}`);
-    const data = accounts[accountKey];
-    if (!data) {
-      throw new Error(`Account not found: ${accountKey}`);
-    }
-    logger.verbose(`Account loaded: ${accountKey} from network: ${this.config.network}`);
-    logger.verbose(`Address: ${data.address}`);
-    const acc = new import_starknet5.Account(this.config.provider, data.address, data.pk, void 0, txVersion);
-    return acc;
-  }
-  addAccount(accountKey, address, pk) {
-    const allAccounts = this.getAllAccounts();
-    if (!allAccounts[this.config.network]) {
-      allAccounts[this.config.network] = {};
-    }
-    allAccounts[this.config.network][accountKey] = {
-      address,
-      pk
-    };
-    const encryptedData = this.encryptor.encrypt(allAccounts, this.storeConfig.PASSWORD);
-    (0, import_fs.writeFileSync)(this.getAccountFilePath(), encryptedData);
-    logger.verbose(`Account added: ${accountKey} to network: ${this.config.network}`);
-  }
-  getAccountFilePath() {
-    const path = `${this.storeConfig.SECRET_FILE_FOLDER}/${this.storeConfig.ACCOUNTS_FILE_NAME}`;
-    logger.verbose(`Path: ${path}`);
-    return path;
-  }
-  getAllAccounts() {
-    const PATH = this.getAccountFilePath();
-    if (!import_fs.default.existsSync(PATH)) {
-      logger.verbose(`Accounts: files doesnt exist`);
-      return {};
-    }
-    let encryptedData = (0, import_fs.readFileSync)(PATH, {
-      encoding: "utf-8"
-    });
-    let data = this.encryptor.decrypt(encryptedData, this.storeConfig.PASSWORD);
-    return data;
-  }
-  /**
-   * @description Load all accounts of the network
-   * @returns NetworkAccounts
-   */
-  loadAccounts() {
-    const allData = this.getAllAccounts();
-    logger.verbose(`Accounts loaded for network: ${this.config.network}`);
-    if (!allData[this.config.network]) {
-      allData[this.config.network] = {};
-    }
-    return allData[this.config.network];
-  }
-  /**
-   * @description List all accountKeys of the network
-   * @returns string[]
-   */
-  listAccounts() {
-    return Object.keys(this.loadAccounts());
-  }
-  static ensureFolder(folder) {
-    if (!import_fs.default.existsSync(folder)) {
-      import_fs.default.mkdirSync(folder, { recursive: true });
-    }
-    if (!import_fs.default.existsSync(`${folder}`)) {
-      throw new Error(`Store folder not found: ${folder}`);
-    }
-  }
-};
 
-// 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)({
+// src/data/vesu-rebalance.abi.json
+var vesu_rebalance_abi_default = [
+  {
+    type: "impl",
+    name: "ExternalImpl",
+    interface_name: "strkfarm_contracts::strategies::vesu_rebalance::interface::IVesuRebal"
+  },
+  {
+    type: "enum",
+    name: "strkfarm_contracts::strategies::vesu_rebalance::interface::Feature",
+    variants: [
+      {
+        name: "DEPOSIT",
+        type: "()"
+      },
+      {
+        name: "WITHDRAW",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::integer::u256",
+    members: [
+      {
+        name: "low",
+        type: "core::integer::u128"
+      },
+      {
+        name: "high",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm_contracts::strategies::vesu_rebalance::interface::Action",
+    members: [
+      {
+        name: "pool_id",
+        type: "core::felt252"
+      },
+      {
+        name: "feature",
+        type: "strkfarm_contracts::strategies::vesu_rebalance::interface::Feature"
+      },
+      {
+        name: "token",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "amount",
+        type: "core::integer::u256"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm_contracts::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_contracts::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_contracts::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_contracts::components::swap::Route>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm_contracts::strategies::vesu_rebalance::interface::Settings",
+    members: [
+      {
+        name: "default_pool_index",
+        type: "core::integer::u8"
+      },
+      {
+        name: "fee_bps",
+        type: "core::integer::u32"
+      },
+      {
+        name: "fee_receiver",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm_contracts::strategies::vesu_rebalance::interface::PoolProps",
+    members: [
+      {
+        name: "pool_id",
+        type: "core::felt252"
+      },
+      {
+        name: "max_weight",
+        type: "core::integer::u32"
+      },
+      {
+        name: "v_token",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "strkfarm_contracts::strategies::vesu_rebalance::interface::IVesuRebal",
+    items: [
+      {
+        type: "function",
+        name: "rebalance",
+        inputs: [
+          {
+            name: "actions",
+            type: "core::array::Array::<strkfarm_contracts::strategies::vesu_rebalance::interface::Action>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "rebalance_weights",
+        inputs: [
+          {
+            name: "actions",
+            type: "core::array::Array::<strkfarm_contracts::strategies::vesu_rebalance::interface::Action>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "emergency_withdraw",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "emergency_withdraw_pool",
+        inputs: [
+          {
+            name: "pool_index",
+            type: "core::integer::u32"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "compute_yield",
+        inputs: [],
+        outputs: [
+          {
+            type: "(core::integer::u256, core::integer::u256)"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "harvest",
+        inputs: [
+          {
+            name: "rewardsContract",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "claim",
+            type: "strkfarm_contracts::interfaces::IEkuboDistributor::Claim"
+          },
+          {
+            name: "proof",
+            type: "core::array::Span::<core::felt252>"
+          },
+          {
+            name: "swapInfo",
+            type: "strkfarm_contracts::components::swap::AvnuMultiRouteSwap"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "set_settings",
+        inputs: [
+          {
+            name: "settings",
+            type: "strkfarm_contracts::strategies::vesu_rebalance::interface::Settings"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "set_allowed_pools",
+        inputs: [
+          {
+            name: "pools",
+            type: "core::array::Array::<strkfarm_contracts::strategies::vesu_rebalance::interface::PoolProps>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "set_incentives_off",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "get_settings",
+        inputs: [],
+        outputs: [
+          {
+            type: "strkfarm_contracts::strategies::vesu_rebalance::interface::Settings"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_allowed_pools",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::array::Array::<strkfarm_contracts::strategies::vesu_rebalance::interface::PoolProps>"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_previous_index",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u128"
+          }
+        ],
+        state_mutability: "view"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "VesuERC4626Impl",
+    interface_name: "strkfarm_contracts::interfaces::IERC4626::IERC4626"
+  },
+  {
+    type: "interface",
+    name: "strkfarm_contracts::interfaces::IERC4626::IERC4626",
+    items: [
+      {
+        type: "function",
+        name: "asset",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "total_assets",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "convert_to_shares",
+        inputs: [
+          {
+            name: "assets",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "convert_to_assets",
+        inputs: [
+          {
+            name: "shares",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "max_deposit",
+        inputs: [
+          {
+            name: "receiver",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "preview_deposit",
+        inputs: [
+          {
+            name: "assets",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "deposit",
+        inputs: [
+          {
+            name: "assets",
+            type: "core::integer::u256"
+          },
+          {
+            name: "receiver",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "max_mint",
+        inputs: [
+          {
+            name: "receiver",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "preview_mint",
+        inputs: [
+          {
+            name: "shares",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "mint",
+        inputs: [
+          {
+            name: "shares",
+            type: "core::integer::u256"
+          },
+          {
+            name: "receiver",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "max_withdraw",
+        inputs: [
+          {
+            name: "owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "preview_withdraw",
+        inputs: [
+          {
+            name: "assets",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "withdraw",
+        inputs: [
+          {
+            name: "assets",
+            type: "core::integer::u256"
+          },
+          {
+            name: "receiver",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "max_redeem",
+        inputs: [
+          {
+            name: "owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "preview_redeem",
+        inputs: [
+          {
+            name: "shares",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "redeem",
+        inputs: [
+          {
+            name: "shares",
+            type: "core::integer::u256"
+          },
+          {
+            name: "receiver",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "VesuERC20Impl",
+    interface_name: "openzeppelin_token::erc20::interface::IERC20Mixin"
+  },
+  {
+    type: "enum",
+    name: "core::bool",
+    variants: [
+      {
+        name: "False",
+        type: "()"
+      },
+      {
+        name: "True",
+        type: "()"
+      }
+    ]
+  },
+  {
+    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::erc20::interface::IERC20Mixin",
+    items: [
+      {
+        type: "function",
+        name: "total_supply",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        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: "allowance",
+        inputs: [
+          {
+            name: "owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "spender",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "transfer",
+        inputs: [
+          {
+            name: "recipient",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "amount",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "transfer_from",
+        inputs: [
+          {
+            name: "sender",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "recipient",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "amount",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "approve",
+        inputs: [
+          {
+            name: "spender",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "amount",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "external"
+      },
+      {
+        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: "decimals",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u8"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "totalSupply",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        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: "transferFrom",
+        inputs: [
+          {
+            name: "sender",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "recipient",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "amount",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "CommonCompImpl",
+    interface_name: "strkfarm_contracts::interfaces::common::ICommon"
+  },
+  {
+    type: "interface",
+    name: "strkfarm_contracts::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: "impl",
+    name: "RewardShareImpl",
+    interface_name: "strkfarm_contracts::components::harvester::reward_shares::IRewardShare"
+  },
+  {
+    type: "struct",
+    name: "strkfarm_contracts::components::harvester::reward_shares::UserRewardsInfo",
+    members: [
+      {
+        name: "pending_round_points",
+        type: "core::integer::u128"
+      },
+      {
+        name: "shares_owned",
+        type: "core::integer::u128"
+      },
+      {
+        name: "block_number",
+        type: "core::integer::u64"
+      },
+      {
+        name: "index",
+        type: "core::integer::u32"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm_contracts::components::harvester::reward_shares::RewardsInfo",
+    members: [
+      {
+        name: "amount",
+        type: "core::integer::u128"
+      },
+      {
+        name: "shares",
+        type: "core::integer::u128"
+      },
+      {
+        name: "total_round_points",
+        type: "core::integer::u128"
+      },
+      {
+        name: "block_number",
+        type: "core::integer::u64"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "strkfarm_contracts::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_contracts::components::harvester::reward_shares::UserRewardsInfo"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_rewards_info",
+        inputs: [
+          {
+            name: "index",
+            type: "core::integer::u32"
+          }
+        ],
+        outputs: [
+          {
+            type: "strkfarm_contracts::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::integer::u128"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_additional_shares",
+        inputs: [
+          {
+            name: "user",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "(core::integer::u128, core::integer::u64, core::integer::u128)"
+          }
+        ],
+        state_mutability: "view"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm_contracts::interfaces::IVesu::IStonDispatcher",
+    members: [
+      {
+        name: "contract_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "strkfarm_contracts::components::vesu::vesuStruct",
+    members: [
+      {
+        name: "singleton",
+        type: "strkfarm_contracts::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: "constructor",
+    name: "constructor",
+    inputs: [
+      {
+        name: "asset",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "access_control",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "allowed_pools",
+        type: "core::array::Array::<strkfarm_contracts::strategies::vesu_rebalance::interface::PoolProps>"
+      },
+      {
+        name: "settings",
+        type: "strkfarm_contracts::strategies::vesu_rebalance::interface::Settings"
+      },
+      {
+        name: "vesu_settings",
+        type: "strkfarm_contracts::components::vesu::vesuStruct"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_security::reentrancyguard::ReentrancyGuardComponent::Event",
+    kind: "enum",
+    variants: []
+  },
+  {
+    type: "event",
+    name: "strkfarm_contracts::components::erc4626::ERC4626Component::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: "shares",
+        type: "core::integer::u256",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm_contracts::components::erc4626::ERC4626Component::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: "shares",
+        type: "core::integer::u256",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm_contracts::components::erc4626::ERC4626Component::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Deposit",
+        type: "strkfarm_contracts::components::erc4626::ERC4626Component::Deposit",
+        kind: "nested"
+      },
+      {
+        name: "Withdraw",
+        type: "strkfarm_contracts::components::erc4626::ERC4626Component::Withdraw",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm_contracts::components::harvester::reward_shares::RewardShareComponent::Rewards",
+    kind: "struct",
+    members: [
+      {
+        name: "index",
+        type: "core::integer::u32",
+        kind: "data"
+      },
+      {
+        name: "info",
+        type: "strkfarm_contracts::components::harvester::reward_shares::RewardsInfo",
+        kind: "data"
+      },
+      {
+        name: "total_reward_shares",
+        type: "core::integer::u128",
+        kind: "data"
+      },
+      {
+        name: "timestamp",
+        type: "core::integer::u64",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm_contracts::components::harvester::reward_shares::RewardShareComponent::UserRewards",
+    kind: "struct",
+    members: [
+      {
+        name: "user",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "info",
+        type: "strkfarm_contracts::components::harvester::reward_shares::UserRewardsInfo",
+        kind: "data"
+      },
+      {
+        name: "total_reward_shares",
+        type: "core::integer::u128",
+        kind: "data"
+      },
+      {
+        name: "timestamp",
+        type: "core::integer::u64",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm_contracts::components::harvester::reward_shares::RewardShareComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Rewards",
+        type: "strkfarm_contracts::components::harvester::reward_shares::RewardShareComponent::Rewards",
+        kind: "nested"
+      },
+      {
+        name: "UserRewards",
+        type: "strkfarm_contracts::components::harvester::reward_shares::RewardShareComponent::UserRewards",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc20::erc20::ERC20Component::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: "value",
+        type: "core::integer::u256",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc20::erc20::ERC20Component::Approval",
+    kind: "struct",
+    members: [
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "spender",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "value",
+        type: "core::integer::u256",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc20::erc20::ERC20Component::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Transfer",
+        type: "openzeppelin_token::erc20::erc20::ERC20Component::Transfer",
+        kind: "nested"
+      },
+      {
+        name: "Approval",
+        type: "openzeppelin_token::erc20::erc20::ERC20Component::Approval",
+        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: "strkfarm_contracts::components::common::CommonComp::Event",
+    kind: "enum",
+    variants: []
+  },
+  {
+    type: "event",
+    name: "strkfarm_contracts::strategies::vesu_rebalance::vesu_rebalance::VesuRebalance::Rebalance",
+    kind: "struct",
+    members: [
+      {
+        name: "yield_before",
+        type: "core::integer::u128",
+        kind: "data"
+      },
+      {
+        name: "yield_after",
+        type: "core::integer::u128",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm_contracts::strategies::vesu_rebalance::vesu_rebalance::VesuRebalance::CollectFees",
+    kind: "struct",
+    members: [
+      {
+        name: "fee_collected",
+        type: "core::integer::u128",
+        kind: "data"
+      },
+      {
+        name: "fee_collector",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "strkfarm_contracts::strategies::vesu_rebalance::vesu_rebalance::VesuRebalance::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "ReentrancyGuardEvent",
+        type: "openzeppelin_security::reentrancyguard::ReentrancyGuardComponent::Event",
+        kind: "flat"
+      },
+      {
+        name: "ERC4626Event",
+        type: "strkfarm_contracts::components::erc4626::ERC4626Component::Event",
+        kind: "flat"
+      },
+      {
+        name: "RewardShareEvent",
+        type: "strkfarm_contracts::components::harvester::reward_shares::RewardShareComponent::Event",
+        kind: "flat"
+      },
+      {
+        name: "ERC20Event",
+        type: "openzeppelin_token::erc20::erc20::ERC20Component::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: "CommonCompEvent",
+        type: "strkfarm_contracts::components::common::CommonComp::Event",
+        kind: "flat"
+      },
+      {
+        name: "Rebalance",
+        type: "strkfarm_contracts::strategies::vesu_rebalance::vesu_rebalance::VesuRebalance::Rebalance",
+        kind: "nested"
+      },
+      {
+        name: "CollectFees",
+        type: "strkfarm_contracts::strategies::vesu_rebalance::vesu_rebalance::VesuRebalance::CollectFees",
+        kind: "nested"
+      }
+    ]
+  }
+];
+
+// src/utils/index.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+// src/strategies/vesu-rebalance.ts
+var import_axios5 = __toESM(require("axios"));
+var VesuRebalance = class _VesuRebalance {
+  // 10000 bps = 100%
+  /**
+   * Creates a new VesuRebalance strategy instance.
+   * @param config - Configuration object containing provider and other settings
+   * @param pricer - Pricer instance for token price calculations
+   * @param metadata - Strategy metadata including deposit tokens and address
+   * @throws {Error} If more than one deposit token is specified
+   */
+  constructor(config, pricer, metadata) {
+    this.BASE_WEIGHT = 1e4;
+    this.config = config;
+    this.pricer = pricer;
+    assert(metadata.depositTokens.length === 1, "VesuRebalance only supports 1 deposit token");
+    this.metadata = metadata;
+    this.address = metadata.address;
+    this.contract = new import_starknet5.Contract(vesu_rebalance_abi_default, this.address.address, this.config.provider);
+  }
+  /**
+   * Creates a deposit call to the strategy contract.
+   * @param assets - Amount of assets to deposit
+   * @param receiver - Address that will receive the strategy tokens
+   * @returns Populated contract call for deposit
+   */
+  depositCall(assets, receiver) {
+    const assetContract = new import_starknet5.Contract(vesu_rebalance_abi_default, this.metadata.depositTokens[0].address, this.config.provider);
+    const call1 = assetContract.populate("approve", [this.address.address, import_starknet5.uint256.bnToUint256(assets.toWei())]);
+    const call2 = this.contract.populate("deposit", [import_starknet5.uint256.bnToUint256(assets.toWei()), receiver.address]);
+    return [call1, call2];
+  }
+  /**
+   * Creates a withdrawal call to the strategy contract.
+   * @param assets - Amount of assets to withdraw
+   * @param receiver - Address that will receive the withdrawn assets
+   * @param owner - Address that owns the strategy tokens
+   * @returns Populated contract call for withdrawal
+   */
+  withdrawCall(assets, receiver, owner) {
+    return [this.contract.populate("withdraw", [import_starknet5.uint256.bnToUint256(assets.toWei()), receiver.address, owner.address])];
+  }
+  /**
+   * Returns the underlying asset token of the strategy.
+   * @returns The deposit token supported by this strategy
+   */
+  asset() {
+    return this.metadata.depositTokens[0];
+  }
+  /**
+   * Returns the number of decimals used by the strategy token.
+   * @returns Number of decimals (same as the underlying token)
+   */
+  decimals() {
+    return this.metadata.depositTokens[0].decimals;
+  }
+  /**
+   * Calculates the Total Value Locked (TVL) for a specific user.
+   * @param user - Address of the user
+   * @returns Object containing the amount in token units and USD value
+   */
+  async getUserTVL(user) {
+    const shares = await this.contract.balanceOf(user.address);
+    const assets = await this.contract.convert_to_assets(import_starknet5.uint256.bnToUint256(shares));
+    const amount = Web3Number.fromWei(assets.toString(), this.metadata.depositTokens[0].decimals);
+    let price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      amount,
+      usdValue
+    };
+  }
+  /**
+   * Calculates the total TVL of the strategy.
+   * @returns Object containing the total amount in token units and USD value
+   */
+  async getTVL() {
+    const assets = await this.contract.total_assets();
+    const amount = Web3Number.fromWei(assets.toString(), this.metadata.depositTokens[0].decimals);
+    let price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      amount,
+      usdValue
+    };
+  }
+  /**
+   * Retrieves the list of allowed pools and their detailed information from multiple sources:
+   * 1. Contract's allowed pools
+   * 2. Vesu positions API for current positions
+   * 3. Vesu pools API for APY and utilization data
+   * 
+   * @returns {Promise<{
+   *   data: Array<PoolInfoFull>,
+   *   isErrorPositionsAPI: boolean
+   * }>} Object containing:
+   *   - data: Array of pool information including IDs, weights, amounts, APYs and utilization
+   *   - isErrorPositionsAPI: Boolean indicating if there was an error fetching position data
+   */
+  async getPools() {
+    const allowedPools = (await this.contract.get_allowed_pools()).map((p) => ({
+      pool_id: ContractAddr.from(p.pool_id),
+      max_weight: Number(p.max_weight) / this.BASE_WEIGHT,
+      v_token: ContractAddr.from(p.v_token)
+    }));
+    let isErrorPositionsAPI = false;
+    let vesuPositions = [];
+    try {
+      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) {
+      console.error(`${_VesuRebalance.name}: Error fetching pools for ${this.address.address}`, e);
+      isErrorPositionsAPI = true;
+    }
+    let isErrorPoolsAPI = false;
+    let pools = [];
+    try {
+      const res = await import_axios5.default.get(`https://api.vesu.xyz/pools`);
+      const data2 = await res.data;
+      pools = data2.data;
+    } catch (e) {
+      console.error(`${_VesuRebalance.name}: Error fetching pools for ${this.address.address}`, e);
+      isErrorPoolsAPI = true;
+    }
+    const totalAssets = (await this.getTVL()).amount;
+    const info = allowedPools.map(async (p) => {
+      const vesuPosition = vesuPositions.find((d) => d.pool.id.toString() === import_starknet5.num.getDecimalString(p.pool_id.address.toString()));
+      const pool = pools.find((d) => d.id == import_starknet5.num.getDecimalString(p.pool_id.address));
+      const assetInfo = pool?.assets.find((d) => ContractAddr.from(this.asset().address).eqString(d.address));
+      let vTokenContract = new import_starknet5.Contract(vesu_rebalance_abi_default, p.v_token.address, this.config.provider);
+      const bal = await vTokenContract.balanceOf(this.address.address);
+      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,
+        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,
+        amount: Web3Number.fromWei(assets.toString(), this.decimals()),
+        usdValue: isErrorPositionsAPI || !vesuPosition ? Web3Number.fromWei("0", this.decimals()) : Web3Number.fromWei(vesuPosition.collateral.usdPrice.value, vesuPosition.collateral.usdPrice.decimals),
+        APY: isErrorPoolsAPI || !assetInfo ? {
+          baseApy: 0,
+          defiSpringApy: 0,
+          netApy: 0
+        } : {
+          baseApy: Number(Web3Number.fromWei(assetInfo.stats.supplyApy.value, assetInfo.stats.supplyApy.decimals).toFixed(6)),
+          defiSpringApy: Number(Web3Number.fromWei(assetInfo.stats.defiSpringSupplyApr.value, assetInfo.stats.defiSpringSupplyApr.decimals).toFixed(6)),
+          netApy: 0
+        },
+        currentUtilization: isErrorPoolsAPI || !assetInfo ? 0 : Number(Web3Number.fromWei(assetInfo.stats.currentUtilization.value, assetInfo.stats.currentUtilization.decimals).toFixed(6)),
+        maxUtilization: isErrorPoolsAPI || !assetInfo ? 0 : Number(Web3Number.fromWei(assetInfo.config.maxUtilization.value, assetInfo.config.maxUtilization.decimals).toFixed(6))
+      };
+      item.APY.netApy = item.APY.baseApy + item.APY.defiSpringApy;
+      return item;
+    });
+    const data = await Promise.all(info);
+    return {
+      data,
+      isErrorPositionsAPI,
+      isErrorPoolsAPI,
+      isError: isErrorPositionsAPI || isErrorPoolsAPI
+    };
+  }
+  /**
+   * Calculates the weighted average APY across all pools based on USD value.
+   * @returns {Promise<number>} The weighted average APY across all pools
+   */
+  async netAPY() {
+    const { data: pools } = await this.getPools();
+    return this.netAPYGivenPools(pools);
+  }
+  /**
+   * Calculates the weighted average APY across all pools based on USD value.
+   * @returns {Promise<number>} The weighted average APY across all pools
+   */
+  netAPYGivenPools(pools) {
+    const weightedApy = pools.reduce((acc, curr) => {
+      const weight = curr.current_weight;
+      return acc + curr.APY.netApy * weight;
+    }, 0);
+    return weightedApy;
+  }
+  /**
+   * Calculates optimal position changes to maximize APY while respecting max weights.
+   * The algorithm:
+   * 1. Sorts pools by APY (highest first)
+   * 2. Calculates target amounts based on max weights
+   * 3. For each pool that needs more funds:
+   *    - Takes funds from lowest APY pools that are over their target
+   * 4. Validates that total assets remain constant
+   * 
+   * @returns {Promise<{  
+   *   changes: Change[],
+   *   finalPools: PoolInfoFull[],
+   *   isAnyPoolOverMaxWeight: boolean
+   * }>} Object containing:
+   *   - changes: Array of position changes
+   *   - finalPools: Array of pool information after rebalance
+   * @throws Error if rebalance is not possible while maintaining constraints
+   */
+  async getRebalancedPositions() {
+    const { data: pools } = await this.getPools();
+    const totalAssets = (await this.getTVL()).amount;
+    if (totalAssets.eq(0)) return {
+      changes: [],
+      finalPools: []
+    };
+    const sumPools = pools.reduce((acc, curr) => acc.plus(curr.amount.toString()), Web3Number.fromWei("0", this.decimals()));
+    assert(sumPools.lte(totalAssets), "Sum of pools.amount must be less than or equal to totalAssets");
+    const sortedPools = [...pools].sort((a, b) => b.APY.netApy - a.APY.netApy);
+    const targetAmounts = {};
+    let remainingAssets = totalAssets;
+    let isAnyPoolOverMaxWeight = false;
+    for (const pool of sortedPools) {
+      const maxAmount = totalAssets.multipliedBy(pool.max_weight * 0.9);
+      const targetAmount = remainingAssets.gte(maxAmount) ? maxAmount : remainingAssets;
+      targetAmounts[pool.pool_id.address.toString()] = targetAmount;
+      remainingAssets = remainingAssets.minus(targetAmount.toString());
+      if (pool.current_weight > pool.max_weight) {
+        isAnyPoolOverMaxWeight = true;
+      }
+    }
+    assert(remainingAssets.lt(1e-5), "Remaining assets must be 0");
+    const changes = sortedPools.map((pool) => {
+      const target = targetAmounts[pool.pool_id.address.toString()] || Web3Number.fromWei("0", this.decimals());
+      const change = Web3Number.fromWei(target.minus(pool.amount.toString()).toWei(), this.decimals());
+      return {
+        pool_id: pool.pool_id,
+        changeAmt: change,
+        finalAmt: target,
+        isDeposit: change.gt(0)
+      };
+    });
+    const sumChanges = changes.reduce((sum, c) => sum.plus(c.changeAmt.toString()), Web3Number.fromWei("0", this.decimals()));
+    const sumFinal = changes.reduce((sum, c) => sum.plus(c.finalAmt.toString()), Web3Number.fromWei("0", this.decimals()));
+    const hasChanges = changes.some((c) => !c.changeAmt.eq(0));
+    if (!sumChanges.eq(0)) throw new Error("Sum of changes must be zero");
+    if (!sumFinal.eq(totalAssets)) throw new Error("Sum of final amounts must equal total assets");
+    if (!hasChanges) throw new Error("No changes required");
+    const finalPools = pools.map((p) => {
+      const target = targetAmounts[p.pool_id.address.toString()] || Web3Number.fromWei("0", this.decimals());
+      return {
+        ...p,
+        amount: target,
+        usdValue: Web3Number.fromWei("0", this.decimals())
+      };
+    });
+    return {
+      changes,
+      finalPools,
+      isAnyPoolOverMaxWeight
+    };
+  }
+  /**
+   * Creates a rebalance Call object for the strategy contract
+   * @param pools - Array of pool information including IDs, weights, amounts, APYs and utilization
+   * @returns Populated contract call for rebalance
+   */
+  async getRebalanceCall(pools, isOverWeightAdjustment) {
+    const actions = [];
+    pools.sort((a, b) => b.isDeposit ? -1 : 1);
+    console.log("pools", pools);
+    pools.forEach((p) => {
+      if (p.changeAmt.eq(0)) return null;
+      actions.push({
+        pool_id: p.pool_id.address,
+        feature: new import_starknet5.CairoCustomEnum(p.isDeposit ? { DEPOSIT: {} } : { WITHDRAW: {} }),
+        token: this.asset().address,
+        amount: import_starknet5.uint256.bnToUint256(p.changeAmt.multipliedBy(p.isDeposit ? 1 : -1).toWei())
+      });
+    });
+    if (actions.length === 0) return null;
+    if (isOverWeightAdjustment) {
+      return this.contract.populate("rebalance_weights", [actions]);
+    }
+    return this.contract.populate("rebalance", [actions]);
+  }
+  async getInvestmentFlows(pools) {
+    const netYield = this.netAPYGivenPools(pools);
+    const baseFlow = {
+      title: "Deposit $1000",
+      subItems: [`Net yield: ${(netYield * 100).toFixed(2)}%`],
+      linkedFlows: []
+    };
+    pools.forEach((p) => {
+      if (p.amount.eq(0)) return;
+      const flow = {
+        title: `${p.pool_name} - $${(p.current_weight * 1e3).toFixed(2)}`,
+        subItems: [
+          `APY: ${(p.APY.netApy * 100).toFixed(2)}%`,
+          `Weight: ${(p.current_weight * 100).toFixed(2)}% / ${(p.max_weight * 100).toFixed(2)}%`
+        ],
+        linkedFlows: []
+      };
+      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],
+  maxTVL: Web3Number.fromWei("0", 18),
+  risk: {
+    riskFactor: _riskFactor,
+    netRisk: _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / 100
+  }
+}];
+
+// 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();
@@ -989,6 +2723,164 @@ var PricerRedis = class extends Pricer {
     return priceInfo;
   }
 };
+
+// src/utils/store.ts
+var import_fs = __toESM(require("fs"));
+var import_starknet6 = require("starknet");
+var crypto2 = __toESM(require("crypto"));
+
+// src/utils/encrypt.ts
+var crypto = __toESM(require("crypto"));
+var PasswordJsonCryptoUtil = class {
+  constructor() {
+    this.algorithm = "aes-256-gcm";
+    this.keyLength = 32;
+    // 256 bits
+    this.saltLength = 16;
+    // 128 bits
+    this.ivLength = 12;
+    // 96 bits for GCM
+    this.tagLength = 16;
+    // 128 bits
+    this.pbkdf2Iterations = 1e5;
+  }
+  // Number of iterations for PBKDF2
+  deriveKey(password, salt) {
+    return crypto.pbkdf2Sync(password, salt, this.pbkdf2Iterations, this.keyLength, "sha256");
+  }
+  encrypt(data, password) {
+    const jsonString = JSON.stringify(data);
+    const salt = crypto.randomBytes(this.saltLength);
+    const iv = crypto.randomBytes(this.ivLength);
+    const key = this.deriveKey(password, salt);
+    const cipher = crypto.createCipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
+    let encrypted = cipher.update(jsonString, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([salt, iv, tag, Buffer.from(encrypted, "hex")]).toString("base64");
+  }
+  decrypt(encryptedData, password) {
+    const data = Buffer.from(encryptedData, "base64");
+    const salt = data.subarray(0, this.saltLength);
+    const iv = data.subarray(this.saltLength, this.saltLength + this.ivLength);
+    const tag = data.subarray(this.saltLength + this.ivLength, this.saltLength + this.ivLength + this.tagLength);
+    const encrypted = data.subarray(this.saltLength + this.ivLength + this.tagLength);
+    const key = this.deriveKey(password, salt);
+    const decipher = crypto.createDecipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
+    decipher.setAuthTag(tag);
+    try {
+      let decrypted = decipher.update(encrypted.toString("hex"), "hex", "utf8");
+      decrypted += decipher.final("utf8");
+      return JSON.parse(decrypted);
+    } catch (error) {
+      throw new Error("Decryption failed. This could be due to an incorrect password or corrupted data.");
+    }
+  }
+};
+
+// src/utils/store.ts
+function getDefaultStoreConfig(network) {
+  if (!process.env.HOME) {
+    throw new Error("StoreConfig: HOME environment variable not found");
+  }
+  return {
+    SECRET_FILE_FOLDER: `${process.env.HOME}/.starknet-store`,
+    NETWORK: network,
+    ACCOUNTS_FILE_NAME: "accounts.json",
+    PASSWORD: crypto2.randomBytes(16).toString("hex")
+  };
+}
+var Store = class _Store {
+  constructor(config, storeConfig) {
+    this.encryptor = new PasswordJsonCryptoUtil();
+    this.config = config;
+    const defaultStoreConfig = getDefaultStoreConfig(config.network);
+    if (!storeConfig.PASSWORD) {
+      _Store.logPassword(defaultStoreConfig.PASSWORD);
+    }
+    this.storeConfig = {
+      ...defaultStoreConfig,
+      ...storeConfig
+    };
+    _Store.ensureFolder(this.storeConfig.SECRET_FILE_FOLDER);
+  }
+  static logPassword(password) {
+    logger.warn(`\u26A0\uFE0F=========================================\u26A0\uFE0F`);
+    logger.warn(`Generated a random password for store`);
+    logger.warn(`\u26A0\uFE0F Password: ${password}`);
+    logger.warn(`This not stored anywhere, please you backup this password for future use`);
+    logger.warn(`\u26A0\uFE0F=========================================\u26A0\uFE0F`);
+  }
+  getAccount(accountKey, txVersion = import_starknet6.constants.TRANSACTION_VERSION.V2) {
+    const accounts = this.loadAccounts();
+    logger.verbose(`nAccounts loaded for network: ${Object.keys(accounts).length}`);
+    const data = accounts[accountKey];
+    if (!data) {
+      throw new Error(`Account not found: ${accountKey}`);
+    }
+    logger.verbose(`Account loaded: ${accountKey} from network: ${this.config.network}`);
+    logger.verbose(`Address: ${data.address}`);
+    const acc = new import_starknet6.Account(this.config.provider, data.address, data.pk, void 0, txVersion);
+    return acc;
+  }
+  addAccount(accountKey, address, pk) {
+    const allAccounts = this.getAllAccounts();
+    if (!allAccounts[this.config.network]) {
+      allAccounts[this.config.network] = {};
+    }
+    allAccounts[this.config.network][accountKey] = {
+      address,
+      pk
+    };
+    const encryptedData = this.encryptor.encrypt(allAccounts, this.storeConfig.PASSWORD);
+    (0, import_fs.writeFileSync)(this.getAccountFilePath(), encryptedData);
+    logger.verbose(`Account added: ${accountKey} to network: ${this.config.network}`);
+  }
+  getAccountFilePath() {
+    const path = `${this.storeConfig.SECRET_FILE_FOLDER}/${this.storeConfig.ACCOUNTS_FILE_NAME}`;
+    logger.verbose(`Path: ${path}`);
+    return path;
+  }
+  getAllAccounts() {
+    const PATH = this.getAccountFilePath();
+    if (!import_fs.default.existsSync(PATH)) {
+      logger.verbose(`Accounts: files doesnt exist`);
+      return {};
+    }
+    let encryptedData = (0, import_fs.readFileSync)(PATH, {
+      encoding: "utf-8"
+    });
+    let data = this.encryptor.decrypt(encryptedData, this.storeConfig.PASSWORD);
+    return data;
+  }
+  /**
+   * @description Load all accounts of the network
+   * @returns NetworkAccounts
+   */
+  loadAccounts() {
+    const allData = this.getAllAccounts();
+    logger.verbose(`Accounts loaded for network: ${this.config.network}`);
+    if (!allData[this.config.network]) {
+      allData[this.config.network] = {};
+    }
+    return allData[this.config.network];
+  }
+  /**
+   * @description List all accountKeys of the network
+   * @returns string[]
+   */
+  listAccounts() {
+    return Object.keys(this.loadAccounts());
+  }
+  static ensureFolder(folder) {
+    if (!import_fs.default.existsSync(folder)) {
+      import_fs.default.mkdirSync(folder, { recursive: true });
+    }
+    if (!import_fs.default.existsSync(`${folder}`)) {
+      throw new Error(`Store folder not found: ${folder}`);
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AutoCompounderSTRK,
@@ -1002,11 +2894,16 @@ var PricerRedis = class extends Pricer {
   PasswordJsonCryptoUtil,
   Pragma,
   Pricer,
+  PricerFromApi,
   PricerRedis,
+  RiskType,
   Store,
   TelegramNotif,
+  VesuRebalance,
+  VesuRebalanceStrategies,
   Web3Number,
   ZkLend,
+  assert,
   getDefaultStoreConfig,
   getMainnetConfig,
   logger