@strkfarm/sdk 1.0.62 → 1.1.0

package/dist/index.mjs

@@ -417,7 +417,7 @@ var Pricer = class extends PricerBase {
   }
   async _getPrice(token, defaultMethod = "all") {
     const methodToUse = this.methodToUse[token.symbol] || defaultMethod;
-    logger.info(`Fetching price of ${token.symbol} using ${methodToUse}`);
+    logger.verbose(`Fetching price of ${token.symbol} using ${methodToUse}`);
     switch (methodToUse) {
       case "Coinbase":
         try {
@@ -582,7 +582,7 @@ var pragma_abi_default = [
 var Pragma = class {
   constructor(provider2) {
     this.contractAddr = "0x023fb3afbff2c0e3399f896dcf7400acf1a161941cfb386e34a123f228c62832";
-    this.contract = new Contract(pragma_abi_default, this.contractAddr, provider2);
+    this.contract = new Contract({ abi: pragma_abi_default, address: this.contractAddr, providerOrAccount: provider2 });
   }
   async getPrice(tokenAddr) {
     if (!tokenAddr) {
@@ -1958,7 +1958,7 @@ var ERC20 = class {
   }
   contract(addr) {
     const _addr = typeof addr === "string" ? addr : addr.address;
-    return new Contract2(erc20_abi_default, _addr, this.config.provider);
+    return new Contract2({ abi: erc20_abi_default, address: _addr, providerOrAccount: this.config.provider });
   }
   async balanceOf(token, address, tokenDecimals) {
     const contract = this.contract(token);
@@ -2121,7 +2121,7 @@ var AvnuWrapper = class _AvnuWrapper {
 };
 
 // src/interfaces/common.tsx
-import { RpcProvider as RpcProvider2 } from "starknet";
+import { BlockTag, RpcProvider as RpcProvider2 } from "starknet";
 import { Fragment, jsx } from "react/jsx-runtime";
 var RiskType = /* @__PURE__ */ ((RiskType2) => {
   RiskType2["MARKET_RISK"] = "Market Risk";
@@ -2147,7 +2147,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 = "https://starknet-mainnet.public.blastapi.io", blockIdentifier = BlockTag.LATEST) {
   return {
     provider: new RpcProvider2({
       nodeUrl: rpcUrl,
@@ -2266,7 +2266,7 @@ var AutoCompounderSTRK = class {
   async init() {
     const provider2 = this.config.provider;
     const cls = await provider2.getClassAt(this.addr.address);
-    this.contract = new Contract3(cls.abi, this.addr.address, provider2);
+    this.contract = new Contract3({ abi: cls.abi, address: this.addr.address, providerOrAccount: provider2 });
     this.initialized = true;
   }
   async waitForInitilisation() {
@@ -3847,7 +3847,7 @@ var Harvests = class _Harvests {
     const unClaimed = [];
     const cls = await this.config.provider.getClassAt(rewards[0].rewardsContract.address);
     for (let reward of rewards) {
-      const contract = new Contract4(cls.abi, reward.rewardsContract.address, this.config.provider);
+      const contract = new Contract4({ abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider });
       const isClaimed = await contract.call("is_claimed", [reward.claim.id]);
       logger.verbose(`${_Harvests.name}: isClaimed: ${isClaimed}`);
       if (isClaimed) {
@@ -3890,13 +3890,14 @@ var EkuboHarvests = class extends Harvests {
     return rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
   }
 };
+var VESU_REWARDS_CONTRACT = ContractAddr.from("0x0387f3eb1d98632fbe3440a9f1385Aec9d87b6172491d3Dd81f1c35A7c61048F");
 var VesuHarvests = class _VesuHarvests extends Harvests {
   async getHarvests(addr) {
     const result = await fetch(`https://api.vesu.xyz/users/${addr.address}/strk-rewards/calldata`);
     const data = await result.json();
-    const rewardsContract = ContractAddr.from("0x0387f3eb1d98632fbe3440a9f1385Aec9d87b6172491d3Dd81f1c35A7c61048F");
+    const rewardsContract = VESU_REWARDS_CONTRACT;
     const cls = await this.config.provider.getClassAt(rewardsContract.address);
-    const contract = new Contract4(cls.abi, rewardsContract.address, this.config.provider);
+    const contract = new Contract4({ abi: cls.abi, address: rewardsContract.address, providerOrAccount: this.config.provider });
     const _claimed_amount = await contract.call("amount_already_claimed", [addr.address]);
     const claimed_amount = Web3Number.fromWei(_claimed_amount.toString(), 18);
     logger.verbose(`${_VesuHarvests.name}: claimed_amount: ${claimed_amount.toString()}`);
@@ -9398,11 +9399,11 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
     );
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new Contract5(
-      vesu_rebalance_abi_default,
-      this.address.address,
-      this.config.provider
-    );
+    this.contract = new Contract5({
+      abi: vesu_rebalance_abi_default,
+      address: this.address.address,
+      providerOrAccount: this.config.provider
+    });
   }
   /**
    * Creates a deposit call to the strategy contract.
@@ -9415,11 +9416,11 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Deposit token mismatch"
     );
-    const assetContract = new Contract5(
-      vesu_rebalance_abi_default,
-      this.asset().address.address,
-      this.config.provider
-    );
+    const assetContract = new Contract5({
+      abi: vesu_rebalance_abi_default,
+      address: this.asset().address.address,
+      providerOrAccount: this.config.provider
+    });
     const call1 = assetContract.populate("approve", [
       this.address.address,
       uint2563.bnToUint256(amountInfo.amount.toWei())
@@ -9552,11 +9553,11 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
         `Asset ${this.asset().address.toString()} not found in pool ${p.pool_id.address.toString()}`
       );
     }
-    let vTokenContract = new Contract5(
-      vesu_rebalance_abi_default,
-      p.v_token.address,
-      this.config.provider
-    );
+    let vTokenContract = new Contract5({
+      abi: vesu_rebalance_abi_default,
+      address: p.v_token.address,
+      providerOrAccount: this.config.provider
+    });
     const bal = await vTokenContract.balanceOf(this.address.address);
     const assets = await vTokenContract.convert_to_assets(
       uint2563.bnToUint256(bal.toString())
@@ -15141,32 +15142,32 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     );
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new Contract6(
-      cl_vault_abi_default,
-      this.address.address,
-      this.config.provider
-    );
+    this.contract = new Contract6({
+      abi: cl_vault_abi_default,
+      address: this.address.address,
+      providerOrAccount: this.config.provider
+    });
     if (this.metadata.additionalInfo.lstContract) {
-      this.lstContract = new Contract6(
-        erc4626_abi_default,
-        this.metadata.additionalInfo.lstContract.address,
-        this.config.provider
-      );
+      this.lstContract = new Contract6({
+        abi: erc4626_abi_default,
+        address: this.metadata.additionalInfo.lstContract.address,
+        providerOrAccount: this.config.provider
+      });
     } else {
       this.lstContract = null;
     }
     const EKUBO_POSITION = "0x02e0af29598b407c8716b17f6d2795eca1b471413fa03fb145a5e33722184067";
-    this.ekuboPositionsContract = new Contract6(
-      ekubo_positions_abi_default,
-      EKUBO_POSITION,
-      this.config.provider
-    );
+    this.ekuboPositionsContract = new Contract6({
+      abi: ekubo_positions_abi_default,
+      address: EKUBO_POSITION,
+      providerOrAccount: this.config.provider
+    });
     const EKUBO_MATH = "0x04a72e9e166f6c0e9d800af4dc40f6b6fb4404b735d3f528d9250808b2481995";
-    this.ekuboMathContract = new Contract6(
-      ekubo_math_abi_default,
-      EKUBO_MATH,
-      this.config.provider
-    );
+    this.ekuboMathContract = new Contract6({
+      abi: ekubo_math_abi_default,
+      address: EKUBO_MATH,
+      providerOrAccount: this.config.provider
+    });
     this.avnu = new AvnuWrapper();
   }
   async matchInputAmounts(amountInfo) {
@@ -15214,16 +15215,16 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
   }
   async depositCall(amountInfo, receiver) {
     const updateAmountInfo = await this.getMinDepositAmounts(amountInfo);
-    const token0Contract = new Contract6(
-      erc4626_abi_default,
-      amountInfo.token0.tokenInfo.address.address,
-      this.config.provider
-    );
-    const token1Contract = new Contract6(
-      erc4626_abi_default,
-      amountInfo.token1.tokenInfo.address.address,
-      this.config.provider
-    );
+    const token0Contract = new Contract6({
+      abi: erc4626_abi_default,
+      address: amountInfo.token0.tokenInfo.address.address,
+      providerOrAccount: this.config.provider
+    });
+    const token1Contract = new Contract6({
+      abi: erc4626_abi_default,
+      address: amountInfo.token1.tokenInfo.address.address,
+      providerOrAccount: this.config.provider
+    });
     const call1 = token0Contract.populate("approve", [
       this.address.address,
       uint2564.bnToUint256(updateAmountInfo.token0.amount.toWei())
@@ -15282,7 +15283,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * Calculates assets before and now in a given token of TVL per share to observe growth
    * @returns {Promise<number>} The weighted average APY across all pools
    */
-  async netAPY(blockIdentifier = "pending", sinceBlocks = 2e4) {
+  async netAPY(blockIdentifier = "pre_confirmed", sinceBlocks = 2e4) {
     const tvlNow = await this._getTVL(blockIdentifier);
     const supplyNow = await this.totalSupply(blockIdentifier);
     const priceNow = await this.getCurrentPrice(blockIdentifier);
@@ -15341,13 +15342,13 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     }
     return shares;
   }
-  async balanceOf(user, blockIdentifier = "pending") {
+  async balanceOf(user, blockIdentifier = "pre_confirmed") {
     let bal = await this.contract.call("balance_of", [user.address], {
       blockIdentifier
     });
     return Web3Number.fromWei(bal.toString(), 18);
   }
-  async getUserTVL(user, blockIdentifier = "pending") {
+  async getUserTVL(user, blockIdentifier = "pre_confirmed") {
     let bal = await this.balanceOf(user, blockIdentifier);
     const assets = await this.contract.call(
       "convert_to_assets",
@@ -15386,7 +15387,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       }
     };
   }
-  async _getTVL(blockIdentifier = "pending") {
+  async _getTVL(blockIdentifier = "pre_confirmed") {
     const result = await this.contract.call("total_liquidity", [], {
       blockIdentifier
     });
@@ -15398,7 +15399,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     );
     return { amount0, amount1 };
   }
-  async totalSupply(blockIdentifier = "pending") {
+  async totalSupply(blockIdentifier = "pre_confirmed") {
     const res = await this.contract.call("total_supply", [], {
       blockIdentifier
     });
@@ -15414,7 +15415,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       "Expected token1 in depositTokens[1]"
     );
   }
-  async getTVL(blockIdentifier = "pending") {
+  async getTVL(blockIdentifier = "pre_confirmed") {
     const { amount0, amount1 } = await this._getTVL(blockIdentifier);
     const poolKey = await this.getPoolKey(blockIdentifier);
     this.assertValidDepositTokens(poolKey);
@@ -15503,11 +15504,11 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     }
     throw new Error("No true price available");
   }
-  async getCurrentPrice(blockIdentifier = "pending") {
+  async getCurrentPrice(blockIdentifier = "pre_confirmed") {
     const poolKey = await this.getPoolKey(blockIdentifier);
     return this._getCurrentPrice(poolKey, blockIdentifier);
   }
-  async _getCurrentPrice(poolKey, blockIdentifier = "pending") {
+  async _getCurrentPrice(poolKey, blockIdentifier = "pre_confirmed") {
     const priceInfo = await this.ekuboPositionsContract.call(
       "get_pool_price",
       [
@@ -15542,7 +15543,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       sqrtRatio: priceInfo.sqrt_ratio.toString()
     };
   }
-  async getCurrentBounds(blockIdentifier = "pending") {
+  async getCurrentBounds(blockIdentifier = "pre_confirmed") {
     const result = await this.contract.call("get_position_key", [], {
       blockIdentifier
     });
@@ -15559,7 +15560,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     const tick = Math.floor(value / tickSpacing) * tickSpacing;
     return this.tickToi129(tick);
   }
-  async getPoolKey(blockIdentifier = "pending") {
+  async getPoolKey(blockIdentifier = "pre_confirmed") {
     if (this.poolKey) {
       return this.poolKey;
     }
@@ -16057,7 +16058,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
   static tickToPrice(tick) {
     return Math.pow(1.000001, Number(tick));
   }
-  async getLiquidityToAmounts(liquidity, bounds, blockIdentifier = "pending", _poolKey = null, _currentPrice = null) {
+  async getLiquidityToAmounts(liquidity, bounds, blockIdentifier = "pre_confirmed", _poolKey = null, _currentPrice = null) {
     const currentPrice = _currentPrice || await this.getCurrentPrice(blockIdentifier);
     const lowerPrice = _EkuboCLVault.tickToPrice(bounds.lowerTick);
     const upperPrice = _EkuboCLVault.tickToPrice(bounds.upperTick);
@@ -18219,7 +18220,7 @@ var SenseiVault = class extends BaseStrategy {
     this.address = metadata.address;
     this.pricer = pricer;
     this.metadata = metadata;
-    this.contract = new Contract7(sensei_abi_default, this.address.address, this.config.provider);
+    this.contract = new Contract7({ abi: sensei_abi_default, address: this.address.address, providerOrAccount: this.config.provider });
     if (metadata.depositTokens.length === 0) {
       throw new Error("Deposit tokens are not defined in metadata");
     }
@@ -18271,11 +18272,11 @@ var SenseiVault = class extends BaseStrategy {
     }
   }
   async depositCall(amountInfo, receiver) {
-    const mainTokenContract = new Contract7(
-      erc20_abi_default,
-      this.metadata.depositTokens[0].address.address,
-      this.config.provider
-    );
+    const mainTokenContract = new Contract7({
+      abi: erc20_abi_default,
+      address: this.metadata.depositTokens[0].address.address,
+      providerOrAccount: this.config.provider
+    });
     const call1 = mainTokenContract.populate("approve", [
       this.address.address,
       uint2565.bnToUint256(amountInfo.amount.toWei())
@@ -18486,7 +18487,9 @@ var SenseiStrategies = [
 import { hash, num as num6, shortString } from "starknet";
 
 // src/strategies/universal-adapters/adapter-utils.ts
-var SIMPLE_SANITIZER = ContractAddr.from("0x3798dc4f83fdfad199e5236e3656cf2fb79bc50c00504d0dd41522e0f042072");
+var SIMPLE_SANITIZER = ContractAddr.from("0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4");
+var PRICE_ROUTER = ContractAddr.from("0x05e83Fa38D791d2dba8E6f487758A9687FfEe191A6Cf8a6c5761ab0a110DB837");
+var AVNU_MIDDLEWARE = ContractAddr.from("0x4a7972ed3f5d1e74a6d6c4a8f467666953d081c8f2270390cc169d50d17cb0d");
 function toBigInt(value) {
   if (typeof value === "string") {
     return BigInt(value);
@@ -18519,7 +18522,7 @@ var BaseAdapter = class extends CacheClass {
 };
 
 // src/strategies/universal-adapters/common-adapter.ts
-import { hash as hash2, uint256 as uint2566 } from "starknet";
+import { hash as hash2, num as num7, uint256 as uint2566 } from "starknet";
 var CommonAdapter = class extends BaseAdapter {
   constructor(config) {
     super();
@@ -18630,10 +18633,70 @@ var CommonAdapter = class extends BaseAdapter {
       };
     };
   }
+  getAvnuAdapter(fromToken, toToken, id) {
+    return () => ({
+      leaf: this.constructSimpleLeafData({
+        id,
+        target: AVNU_MIDDLEWARE,
+        method: "multi_route_swap",
+        packedArguments: [
+          fromToken.toBigInt(),
+          toToken.toBigInt(),
+          this.config.vaultAllocator.toBigInt()
+        ]
+      }),
+      callConstructor: this.getAvnuCall(fromToken, toToken).bind(this)
+    });
+  }
+  getAvnuCall(fromToken, toToken) {
+    return (params) => {
+      return {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: AVNU_MIDDLEWARE,
+          selector: hash2.getSelectorFromName("multi_route_swap"),
+          calldata: [
+            fromToken.toBigInt(),
+            // sell_token_address
+            toBigInt(params.props.token_from_amount.low.toString()),
+            // sell_token_amount low
+            toBigInt(params.props.token_from_amount.high.toString()),
+            // sell_token_amount high
+            toToken.toBigInt(),
+            // buy_token_address
+            toBigInt(params.props.token_to_amount.low.toString()),
+            // buy_token_amount low
+            toBigInt(params.props.token_to_amount.high.toString()),
+            // buy_token_amount high
+            toBigInt(params.props.token_to_min_amount.low.toString()),
+            // buy_token_min_amount low
+            toBigInt(params.props.token_to_min_amount.high.toString()),
+            // buy_token_min_amount high
+            this.config.vaultAllocator.toBigInt(),
+            // beneficiary
+            toBigInt(0),
+            // integrator_fee_amount_bps
+            this.config.vaultAllocator.toBigInt(),
+            // integrator_fee_recipient
+            // unpack routes
+            BigInt(params.props.routes.length),
+            ...params.props.routes.map((r) => [
+              BigInt(num7.hexToDecimalString(r.token_from)),
+              BigInt(num7.hexToDecimalString(r.token_to)),
+              BigInt(num7.hexToDecimalString(r.exchange_address)),
+              BigInt(r.percent),
+              BigInt(r.additional_swap_params.length),
+              ...r.additional_swap_params.map((p) => BigInt(num7.hexToDecimalString(p)))
+            ]).flat()
+          ]
+        }
+      };
+    };
+  }
 };
 
 // src/strategies/universal-adapters/vesu-adapter.ts
-import { CairoCustomEnum as CairoCustomEnum2, Contract as Contract8, hash as hash3, RpcProvider as RpcProvider4, uint256 as uint2567 } from "starknet";
+import { CairoCustomEnum as CairoCustomEnum2, Contract as Contract8, hash as hash3, num as num8, RpcProvider as RpcProvider4, shortString as shortString3, uint256 as uint2567 } from "starknet";
 
 // src/data/vesu-singleton.abi.json
 var vesu_singleton_abi_default = [
@@ -20943,7 +21006,7 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         }
       };
       logger.verbose(`VesuAdapter::ConstructingModify::Debt::${JSON.stringify(_debt)}`);
-      const singletonContract = new Contract8(vesu_singleton_abi_default, this.VESU_SINGLETON.toString(), new RpcProvider4({ nodeUrl: "" }));
+      const singletonContract = new Contract8({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.toString(), providerOrAccount: new RpcProvider4({ nodeUrl: "" }) });
       const call = singletonContract.populate("modify_position", {
         params: {
           pool_id: this.config.poolId.toBigInt(),
@@ -20966,6 +21029,40 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         }
       };
     };
+    this.getDefispringRewardsAdapter = (id) => {
+      return () => {
+        const packedArguments = [];
+        const output = {
+          id: BigInt(num8.getDecimalString(shortString3.encodeShortString(id))),
+          readableId: id,
+          data: [
+            SIMPLE_SANITIZER.toBigInt(),
+            // sanitizer address
+            VESU_REWARDS_CONTRACT.toBigInt(),
+            // contract
+            toBigInt(hash3.getSelectorFromName("claim")),
+            // method name
+            BigInt(packedArguments.length),
+            ...packedArguments
+          ]
+        };
+        return { leaf: output, callConstructor: this.getDefiSpringClaimCall().bind(this) };
+      };
+    };
+    this.getDefiSpringClaimCall = () => {
+      return (params) => ({
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: VESU_REWARDS_CONTRACT,
+          selector: hash3.getSelectorFromName("claim"),
+          calldata: [
+            BigInt(params.amount.toWei()),
+            BigInt(params.proofs.length),
+            ...params.proofs.map((proof) => BigInt(num8.hexToDecimalString(proof)))
+          ]
+        }
+      });
+    };
     this.config = config;
   }
   static getDefaultModifyPositionCallParams(params) {
@@ -21007,7 +21104,7 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     throw new Error(`Unknown VesuAmountDenomination: ${denomination}`);
   }
   getVesuSingletonContract(config) {
-    return new Contract8(vesu_singleton_abi_default, this.VESU_SINGLETON.address, config.provider);
+    return new Contract8({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.address, providerOrAccount: config.provider });
   }
   async getLTVConfig(config) {
     const CACHE_KEY = "ltv_config";
@@ -23370,16 +23467,16 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     );
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new Contract9(
-      universal_vault_abi_default,
-      this.address.address,
-      this.config.provider
-    );
-    this.managerContract = new Contract9(
-      vault_manager_abi_default,
-      this.metadata.additionalInfo.manager.address,
-      this.config.provider
-    );
+    this.contract = new Contract9({
+      abi: universal_vault_abi_default,
+      address: this.address.address,
+      providerOrAccount: this.config.provider
+    });
+    this.managerContract = new Contract9({
+      abi: vault_manager_abi_default,
+      address: this.metadata.additionalInfo.manager.address,
+      providerOrAccount: this.config.provider
+    });
   }
   getMerkleTree() {
     if (this.merkleTree) return this.merkleTree;
@@ -23429,11 +23526,11 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Deposit token mismatch"
     );
-    const assetContract = new Contract9(
-      universal_vault_abi_default,
-      this.asset().address.address,
-      this.config.provider
-    );
+    const assetContract = new Contract9({
+      abi: universal_vault_abi_default,
+      address: this.asset().address.address,
+      providerOrAccount: this.config.provider
+    });
     const call1 = assetContract.populate("approve", [
       this.address.address,
       uint2568.bnToUint256(amountInfo.amount.toWei())
@@ -23595,7 +23692,7 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const aumToken = vesuAum.plus(balance.amount);
     logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
     const netAPY = await this.netAPY();
-    const defispringAPY = netAPY.splits.find((s) => s.id === "defispring")?.apy || 0;
+    const defispringAPY = (netAPY.splits.find((s) => s.id === "defispring")?.apy || 0) * 0.8;
     if (!defispringAPY) throw new Error("DefiSpring APY not found");
     const timeDiff = Math.round(Date.now() / 1e3) - Number(lastReportTime);
     const growthRate = timeDiff * defispringAPY / (365 * 24 * 60 * 60);
@@ -23838,6 +23935,51 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const manageCall = this.getManageCall(["approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */, "bring_liquidity" /* BRING_LIQUIDITY */], [manageCall1, manageCall2]);
     return manageCall;
   }
+  async getHarvestCall() {
+    const vesuHarvest = new VesuHarvests(this.config);
+    const harvestInfo = await vesuHarvest.getUnHarvestedRewards(this.metadata.additionalInfo.vaultAllocator);
+    if (harvestInfo.length != 1) {
+      throw new Error(`Expected 1 harvest info, got ${harvestInfo.length}`);
+    }
+    const amount = harvestInfo[0].claim.amount;
+    const actualReward = harvestInfo[0].actualReward;
+    const proofs = harvestInfo[0].proof;
+    if (actualReward.isZero()) {
+      throw new Error(`Expected non-zero actual reward, got ${harvestInfo[0].actualReward}`);
+    }
+    const manage1Info = this.getProofs("defispring_rewards" /* DEFISPRING_REWARDS */);
+    const manageCall1 = manage1Info.callConstructor({
+      amount,
+      proofs
+    });
+    const proofIds = ["defispring_rewards" /* DEFISPRING_REWARDS */];
+    const manageCalls = [manageCall1];
+    const STRK2 = Global.getDefaultTokens().find((t) => t.symbol === "STRK");
+    if (this.asset().symbol != "STRK") {
+      const manage2Info = this.getProofs("approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */);
+      const manageCall2 = manage2Info.callConstructor({
+        amount: actualReward
+      });
+      const avnuModule = new AvnuWrapper();
+      const quote = await avnuModule.getQuotes(
+        STRK2.address.address,
+        this.asset().address.address,
+        actualReward.toWei(),
+        this.address.address
+      );
+      const swapInfo = await avnuModule.getSwapInfo(quote, this.address.address, 0, this.address.address);
+      const manage3Info = this.getProofs("avnu_swap_rewards" /* AVNU_SWAP_REWARDS */);
+      const manageCall3 = manage3Info.callConstructor({
+        props: swapInfo
+      });
+      proofIds.push("approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */);
+      proofIds.push("avnu_swap_rewards" /* AVNU_SWAP_REWARDS */);
+      manageCalls.push(manageCall2);
+      manageCalls.push(manageCall3);
+    }
+    const manageCall = this.getManageCall(proofIds, manageCalls);
+    return { call: manageCall, reward: actualReward, tokenInfo: STRK2 };
+  }
   async getRebalanceCall(params) {
     let callSet1 = this.getVesuModifyPositionCalls({
       isLeg1: true,
@@ -23874,6 +24016,9 @@ var UNIVERSAL_MANAGE_IDS = /* @__PURE__ */ ((UNIVERSAL_MANAGE_IDS2) => {
   UNIVERSAL_MANAGE_IDS2["APPROVE_TOKEN2"] = "approve_token2";
   UNIVERSAL_MANAGE_IDS2["APPROVE_BRING_LIQUIDITY"] = "approve_bring_liquidity";
   UNIVERSAL_MANAGE_IDS2["BRING_LIQUIDITY"] = "bring_liquidity";
+  UNIVERSAL_MANAGE_IDS2["DEFISPRING_REWARDS"] = "defispring_rewards";
+  UNIVERSAL_MANAGE_IDS2["APPROVE_SWAP_TOKEN1"] = "approve_swap_token1";
+  UNIVERSAL_MANAGE_IDS2["AVNU_SWAP_REWARDS"] = "avnu_swap_rewards";
   return UNIVERSAL_MANAGE_IDS2;
 })(UNIVERSAL_MANAGE_IDS || {});
 var UNIVERSAL_ADAPTERS = /* @__PURE__ */ ((UNIVERSAL_ADAPTERS2) => {
@@ -23923,6 +24068,10 @@ function getLooperSettings(token1Symbol, token2Symbol, vaultSettings, pool1, poo
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(ETHToken.address, vesuAdapterETHUSDC.VESU_SINGLETON, "approve_token2" /* APPROVE_TOKEN2 */).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.address, vaultSettings.vaultAddress, "approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter("bring_liquidity" /* BRING_LIQUIDITY */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterUSDCETH.getDefispringRewardsAdapter("defispring_rewards" /* DEFISPRING_REWARDS */).bind(vesuAdapterUSDCETH));
+  const STRKToken = Global.getDefaultTokens().find((token) => token.symbol === "STRK");
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_MIDDLEWARE, "approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, USDCToken.address, "avnu_swap_rewards" /* AVNU_SWAP_REWARDS */).bind(commonAdapter));
   return vaultSettings;
 }
 var _riskFactor4 = [
@@ -24320,12 +24469,12 @@ var PricerRedis = class extends Pricer {
 
 // src/node/deployer.ts
 import assert2 from "assert";
-import { TransactionExecutionStatus, constants as constants3, extractContractHashes, json, num as num10, transaction } from "starknet";
+import { Deployer as SnDeployer, TransactionExecutionStatus, constants as constants3, extractContractHashes, json, num as num10 } from "starknet";
 import { readFileSync as readFileSync2, existsSync, writeFileSync as writeFileSync2 } from "fs";
 
 // src/utils/store.ts
 import fs, { readFileSync, writeFileSync } from "fs";
-import { Account as Account3, constants as constants2 } from "starknet";
+import { Account as Account3 } from "starknet";
 import * as crypto2 from "crypto";
 
 // src/utils/encrypt.ts
@@ -24410,7 +24559,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 = constants2.TRANSACTION_VERSION.V2) {
+  getAccount(accountKey, txVersion) {
     const accounts = this.loadAccounts();
     logger.verbose(`nAccounts loaded for network: ${Object.keys(accounts).length}`);
     const data = accounts[accountKey];
@@ -24419,7 +24568,13 @@ var Store = class _Store {
     }
     logger.verbose(`Account loaded: ${accountKey} from network: ${this.config.network}`);
     logger.verbose(`Address: ${data.address}`);
-    const acc = new Account3(this.config.provider, data.address, data.pk, void 0, txVersion);
+    const acc = new Account3({
+      provider: this.config.provider,
+      address: data.address,
+      signer: data.pk,
+      cairoVersion: void 0,
+      transactionVersion: txVersion
+    });
     return acc;
   }
   addAccount(accountKey, address, pk) {
@@ -24578,7 +24733,7 @@ async function prepareMultiDeployContracts(contracts, config, acc) {
   for (const { contract_name, package_name, constructorData } of contracts) {
     const declaredInfo = await myDeclare(contract_name, package_name, config, acc);
     const classHash = declaredInfo.class_hash;
-    const { calls, addresses } = transaction.buildUDCCall({
+    const { calls, addresses } = new SnDeployer().buildDeployerCall({
       classHash,
       constructorCalldata: constructorData
     }, acc.address);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.0.62",
+  "version": "1.1.0",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",
@@ -54,7 +54,7 @@
     "@types/react": "^19.1.2",
     "axios": "^1.7.2",
     "react": "19.1.0",
-    "starknet": "7.6.4"
+    "starknet": "8.5.2"
   },
   "dependencies": {
     "@avnu/avnu-sdk": "3.0.2",