@strkfarm/sdk 1.1.2 → 1.1.3

package/dist/index.browser.global.js

@@ -20261,14 +20261,14 @@ ${r2}}` : "}", l2;
         keccakBn: () => keccakBn2,
         starknetKeccak: () => starknetKeccak2
       });
-      var import_starknet22 = require_lib3();
+      var import_starknet23 = require_lib3();
       function keccakBn2(value) {
         const hexWithoutPrefix = removeHexPrefix2(toHex3(BigInt(value)));
         const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
-        return addHexPrefix2((0, import_starknet22.keccak)(hexToBytes4(addHexPrefix2(evenHex))).toString(16));
+        return addHexPrefix2((0, import_starknet23.keccak)(hexToBytes4(addHexPrefix2(evenHex))).toString(16));
       }
       function keccakHex2(str) {
-        return addHexPrefix2((0, import_starknet22.keccak)(utf8ToArray2(str)).toString(16));
+        return addHexPrefix2((0, import_starknet23.keccak)(utf8ToArray2(str)).toString(16));
       }
       function starknetKeccak2(str) {
         const hash2 = BigInt(keccakHex2(str));
@@ -22280,7 +22280,7 @@ ${r2}}` : "}", l2;
         hashDAMode: () => hashDAMode2,
         hashFeeField: () => hashFeeField
       });
-      var import_starknet23 = require_lib3();
+      var import_starknet24 = require_lib3();
       var AToBI2 = (array) => array.map((it) => BigInt(it));
       var DATA_AVAILABILITY_MODE_BITS2 = 32n;
       var MAX_AMOUNT_BITS2 = 64n;
@@ -22294,7 +22294,7 @@ ${r2}}` : "}", l2;
       function hashFeeField(tip, bounds) {
         const L1Bound = (L1_GAS_NAME2 << RESOURCE_VALUE_OFFSET2) + (BigInt(bounds.l1_gas.max_amount) << MAX_PRICE_PER_UNIT_BITS2) + BigInt(bounds.l1_gas.max_price_per_unit);
         const L2Bound = (L2_GAS_NAME2 << RESOURCE_VALUE_OFFSET2) + (BigInt(bounds.l2_gas.max_amount) << MAX_PRICE_PER_UNIT_BITS2) + BigInt(bounds.l2_gas.max_price_per_unit);
-        return (0, import_starknet23.poseidonHashMany)([BigInt(tip), L1Bound, L2Bound]);
+        return (0, import_starknet24.poseidonHashMany)([BigInt(tip), L1Bound, L2Bound]);
       }
       function calculateTransactionHashCommon22(txHashPrefix, version4, senderAddress, chainId, nonce, tip, paymasterData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, additionalData = []) {
         const feeFieldHash = hashFeeField(tip, resourceBounds);
@@ -22304,13 +22304,13 @@ ${r2}}` : "}", l2;
           version4,
           senderAddress,
           feeFieldHash,
-          (0, import_starknet23.poseidonHashMany)(AToBI2(paymasterData)),
+          (0, import_starknet24.poseidonHashMany)(AToBI2(paymasterData)),
           chainId,
           nonce,
           dAModeHash,
           ...AToBI2(additionalData)
         ]);
-        return toHex3((0, import_starknet23.poseidonHashMany)(dataToHash));
+        return toHex3((0, import_starknet24.poseidonHashMany)(dataToHash));
       }
       function calculateDeployAccountTransactionHash22(contractAddress, classHash, compiledConstructorCalldata, salt, version4, chainId, nonce, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
         return calculateTransactionHashCommon22(
@@ -22324,7 +22324,7 @@ ${r2}}` : "}", l2;
           nonceDataAvailabilityMode,
           feeDataAvailabilityMode,
           resourceBounds,
-          [(0, import_starknet23.poseidonHashMany)(AToBI2(compiledConstructorCalldata)), classHash, salt]
+          [(0, import_starknet24.poseidonHashMany)(AToBI2(compiledConstructorCalldata)), classHash, salt]
         );
       }
       function calculateDeclareTransactionHash22(classHash, compiledClassHash, senderAddress, version4, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
@@ -22339,7 +22339,7 @@ ${r2}}` : "}", l2;
           nonceDataAvailabilityMode,
           feeDataAvailabilityMode,
           resourceBounds,
-          [(0, import_starknet23.poseidonHashMany)(AToBI2(accountDeploymentData)), classHash, compiledClassHash]
+          [(0, import_starknet24.poseidonHashMany)(AToBI2(accountDeploymentData)), classHash, compiledClassHash]
         );
       }
       function calculateInvokeTransactionHash3(senderAddress, version4, compiledCalldata, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
@@ -22354,7 +22354,7 @@ ${r2}}` : "}", l2;
           nonceDataAvailabilityMode,
           feeDataAvailabilityMode,
           resourceBounds,
-          [(0, import_starknet23.poseidonHashMany)(AToBI2(accountDeploymentData)), (0, import_starknet23.poseidonHashMany)(AToBI2(compiledCalldata))]
+          [(0, import_starknet24.poseidonHashMany)(AToBI2(accountDeploymentData)), (0, import_starknet24.poseidonHashMany)(AToBI2(compiledCalldata))]
         );
       }
       function isV3InvokeTx2(args) {

package/dist/index.browser.mjs

@@ -1933,7 +1933,7 @@ import { processMultiProof, processProof } from "@ericnordelo/strk-merkle-tree/d
 import { standardLeafHash } from "@ericnordelo/strk-merkle-tree/dist/hashes";
 import { MerkleTreeImpl } from "@ericnordelo/strk-merkle-tree/dist/merkletree";
 import { num as num2 } from "starknet";
-import * as starknet from "@scure/starknet";
+import { pedersen } from "@scure/starknet";
 function hash_leaf(leaf) {
   if (leaf.data.length < 1) {
     throw new Error("Invalid leaf data");
@@ -1946,7 +1946,7 @@ function hash_leaf(leaf) {
   return `0x${num2.toHexString(value).replace(/^0x/, "").padStart(64, "0")}`;
 }
 function pedersen_hash(a, b) {
-  return BigInt(starknet.pedersen(a, b).toString());
+  return BigInt(pedersen(a, b).toString());
 }
 var StandardMerkleTree = class _StandardMerkleTree extends MerkleTreeImpl {
   constructor(tree, values, leafEncoding) {

package/dist/index.js

@@ -2060,7 +2060,7 @@ var ERC20 = class {
 };
 
 // src/modules/avnu.ts
-var import_starknet5 = require("starknet");
+var import_starknet6 = require("starknet");
 var import_avnu_sdk = require("@avnu/avnu-sdk");
 
 // src/utils/oz-merkle.ts
@@ -2069,7 +2069,7 @@ var import_core = require("@ericnordelo/strk-merkle-tree/dist/core");
 var import_hashes = require("@ericnordelo/strk-merkle-tree/dist/hashes");
 var import_merkletree = require("@ericnordelo/strk-merkle-tree/dist/merkletree");
 var import_starknet4 = require("starknet");
-var starknet = __toESM(require("@scure/starknet"));
+var import_starknet5 = require("@scure/starknet");
 function hash_leaf(leaf) {
   if (leaf.data.length < 1) {
     throw new Error("Invalid leaf data");
@@ -2082,7 +2082,7 @@ function hash_leaf(leaf) {
   return `0x${import_starknet4.num.toHexString(value).replace(/^0x/, "").padStart(64, "0")}`;
 }
 function pedersen_hash(a, b) {
-  return BigInt(starknet.pedersen(a, b).toString());
+  return BigInt((0, import_starknet5.pedersen)(a, b).toString());
 }
 var StandardMerkleTree = class _StandardMerkleTree extends import_merkletree.MerkleTreeImpl {
   constructor(tree, values, leafEncoding) {
@@ -2181,10 +2181,10 @@ var AvnuWrapper = class _AvnuWrapper {
     logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo = {
       token_from_address: quote.sellTokenAddress,
-      token_from_amount: import_starknet5.uint256.bnToUint256(quote.sellAmount),
+      token_from_amount: import_starknet6.uint256.bnToUint256(quote.sellAmount),
       token_to_address: quote.buyTokenAddress,
-      token_to_amount: import_starknet5.uint256.bnToUint256(_minAmount),
-      token_to_min_amount: import_starknet5.uint256.bnToUint256(_minAmount),
+      token_to_amount: import_starknet6.uint256.bnToUint256(_minAmount),
+      token_to_min_amount: import_starknet6.uint256.bnToUint256(_minAmount),
       beneficiary: taker,
       integrator_fee_amount_bps: integratorFeeBps,
       integrator_fee_recipient: integratorFeeRecipient,
@@ -2195,10 +2195,10 @@ var AvnuWrapper = class _AvnuWrapper {
   static buildZeroSwap(tokenToSell, address) {
     return {
       token_from_address: tokenToSell.address,
-      token_from_amount: import_starknet5.uint256.bnToUint256(0),
+      token_from_amount: import_starknet6.uint256.bnToUint256(0),
       token_to_address: tokenToSell.address,
-      token_to_amount: import_starknet5.uint256.bnToUint256(0),
-      token_to_min_amount: import_starknet5.uint256.bnToUint256(0),
+      token_to_amount: import_starknet6.uint256.bnToUint256(0),
+      token_to_min_amount: import_starknet6.uint256.bnToUint256(0),
       beneficiary: address,
       integrator_fee_amount_bps: 0,
       integrator_fee_recipient: address,
@@ -2208,7 +2208,7 @@ var AvnuWrapper = class _AvnuWrapper {
 };
 
 // src/interfaces/common.tsx
-var import_starknet6 = require("starknet");
+var import_starknet7 = require("starknet");
 var import_jsx_runtime = require("react/jsx-runtime");
 var RiskType = /* @__PURE__ */ ((RiskType2) => {
   RiskType2["MARKET_RISK"] = "Market Risk";
@@ -2234,9 +2234,9 @@ var FlowChartColors = /* @__PURE__ */ ((FlowChartColors2) => {
   FlowChartColors2["Purple"] = "#6e53dc";
   return FlowChartColors2;
 })(FlowChartColors || {});
-function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blastapi.io", blockIdentifier = import_starknet6.BlockTag.LATEST) {
+function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blastapi.io", blockIdentifier = import_starknet7.BlockTag.LATEST) {
   return {
-    provider: new import_starknet6.RpcProvider({
+    provider: new import_starknet7.RpcProvider({
       nodeUrl: rpcUrl,
       blockIdentifier
       // specVersion
@@ -2330,7 +2330,7 @@ var Initializable = class {
 };
 
 // src/strategies/autoCompounderStrk.ts
-var import_starknet7 = require("starknet");
+var import_starknet8 = require("starknet");
 var AutoCompounderSTRK = class {
   constructor(config, pricer) {
     this.addr = ContractAddr.from("0x541681b9ad63dff1b35f79c78d8477f64857de29a27902f7298f7b620838ea");
@@ -2353,7 +2353,7 @@ var AutoCompounderSTRK = class {
   async init() {
     const provider2 = this.config.provider;
     const cls = await provider2.getClassAt(this.addr.address);
-    this.contract = new import_starknet7.Contract({ abi: cls.abi, address: this.addr.address, providerOrAccount: provider2 });
+    this.contract = new import_starknet8.Contract({ abi: cls.abi, address: this.addr.address, providerOrAccount: provider2 });
     this.initialized = true;
   }
   async waitForInitilisation() {
@@ -2374,7 +2374,7 @@ var AutoCompounderSTRK = class {
   /** Returns underlying assets of user */
   async balanceOfUnderlying(user) {
     const balanceShares = await this.balanceOf(user);
-    const assets = await this.contract.convert_to_assets(import_starknet7.uint256.bnToUint256(balanceShares.toWei()));
+    const assets = await this.contract.convert_to_assets(import_starknet8.uint256.bnToUint256(balanceShares.toWei()));
     return Web3Number.fromWei(assets.toString(), this.metadata.decimals);
   }
   /** Returns usd value of assets */
@@ -2390,7 +2390,7 @@ var AutoCompounderSTRK = class {
 };
 
 // src/strategies/vesu-rebalance.tsx
-var import_starknet9 = require("starknet");
+var import_starknet10 = require("starknet");
 
 // src/data/vesu-rebalance.abi.json
 var vesu_rebalance_abi_default = [
@@ -3920,7 +3920,7 @@ async function getAPIUsingHeadlessBrowser(url) {
 }
 
 // src/modules/harvests.ts
-var import_starknet8 = require("starknet");
+var import_starknet9 = require("starknet");
 var Harvests = class _Harvests {
   constructor(config) {
     this.config = config;
@@ -3934,7 +3934,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 import_starknet8.Contract({ abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider });
+      const contract = new import_starknet9.Contract({ 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) {
@@ -3984,7 +3984,7 @@ var VesuHarvests = class _VesuHarvests extends Harvests {
     const data = await result.json();
     const rewardsContract = VESU_REWARDS_CONTRACT;
     const cls = await this.config.provider.getClassAt(rewardsContract.address);
-    const contract = new import_starknet8.Contract({ abi: cls.abi, address: rewardsContract.address, providerOrAccount: this.config.provider });
+    const contract = new import_starknet9.Contract({ 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()}`);
@@ -3997,7 +3997,7 @@ var VesuHarvests = class _VesuHarvests extends Harvests {
       endDate: /* @__PURE__ */ new Date(0),
       claim: {
         id: 0,
-        amount: Web3Number.fromWei(import_starknet8.num.getDecimalString(data.data.amount), 18),
+        amount: Web3Number.fromWei(import_starknet9.num.getDecimalString(data.data.amount), 18),
         claimee: addr
       },
       actualReward,
@@ -9486,7 +9486,7 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
     );
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new import_starknet9.Contract({
+    this.contract = new import_starknet10.Contract({
       abi: vesu_rebalance_abi_default,
       address: this.address.address,
       providerOrAccount: this.config.provider
@@ -9503,17 +9503,17 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Deposit token mismatch"
     );
-    const assetContract = new import_starknet9.Contract({
+    const assetContract = new import_starknet10.Contract({
       abi: vesu_rebalance_abi_default,
       address: this.asset().address.address,
       providerOrAccount: this.config.provider
     });
     const call1 = assetContract.populate("approve", [
       this.address.address,
-      import_starknet9.uint256.bnToUint256(amountInfo.amount.toWei())
+      import_starknet10.uint256.bnToUint256(amountInfo.amount.toWei())
     ]);
     const call2 = this.contract.populate("deposit", [
-      import_starknet9.uint256.bnToUint256(amountInfo.amount.toWei()),
+      import_starknet10.uint256.bnToUint256(amountInfo.amount.toWei()),
       receiver.address
     ]);
     return [call1, call2];
@@ -9528,7 +9528,7 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
   async withdrawCall(amountInfo, receiver, owner) {
     return [
       this.contract.populate("withdraw", [
-        import_starknet9.uint256.bnToUint256(amountInfo.amount.toWei()),
+        import_starknet10.uint256.bnToUint256(amountInfo.amount.toWei()),
         receiver.address,
         owner.address
       ])
@@ -9556,7 +9556,7 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
   async getUserTVL(user) {
     const shares = await this.contract.balanceOf(user.address);
     const assets = await this.contract.convert_to_assets(
-      import_starknet9.uint256.bnToUint256(shares)
+      import_starknet10.uint256.bnToUint256(shares)
     );
     const amount = Web3Number.fromWei(
       assets.toString(),
@@ -9611,15 +9611,15 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
   }
   async getPoolInfo(p, pools, vesuPositions, totalAssets, isErrorPositionsAPI, isErrorPoolsAPI) {
     const vesuPosition = vesuPositions.find(
-      (d) => d.pool.id.toString() === import_starknet9.num.getDecimalString(p.pool_id.address.toString())
+      (d) => d.pool.id.toString() === import_starknet10.num.getDecimalString(p.pool_id.address.toString())
     );
     const _pool = pools.find((d) => {
       logger.verbose(
-        `pool check: ${d.id == import_starknet9.num.getDecimalString(p.pool_id.address.toString())}, id: ${d.id}, pool_id: ${import_starknet9.num.getDecimalString(
+        `pool check: ${d.id == import_starknet10.num.getDecimalString(p.pool_id.address.toString())}, id: ${d.id}, pool_id: ${import_starknet10.num.getDecimalString(
           p.pool_id.address.toString()
         )}`
       );
-      return d.id == import_starknet9.num.getDecimalString(p.pool_id.address.toString());
+      return d.id == import_starknet10.num.getDecimalString(p.pool_id.address.toString());
     });
     logger.verbose(`pool: ${JSON.stringify(_pool)}`);
     logger.verbose(typeof _pool);
@@ -9640,14 +9640,14 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
         `Asset ${this.asset().address.toString()} not found in pool ${p.pool_id.address.toString()}`
       );
     }
-    let vTokenContract = new import_starknet9.Contract({
+    let vTokenContract = new import_starknet10.Contract({
       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(
-      import_starknet9.uint256.bnToUint256(bal.toString())
+      import_starknet10.uint256.bnToUint256(bal.toString())
     );
     logger.verbose(`Collateral: ${JSON.stringify(vesuPosition?.collateral)}`);
     logger.verbose(`supplyApy: ${JSON.stringify(assetInfo?.stats.supplyApy)}`);
@@ -9949,11 +9949,11 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
       if (p.changeAmt.eq(0)) return null;
       actions.push({
         pool_id: p.pool_id.address,
-        feature: new import_starknet9.CairoCustomEnum(
+        feature: new import_starknet10.CairoCustomEnum(
           p.isDeposit ? { DEPOSIT: {} } : { WITHDRAW: {} }
         ),
         token: this.asset().address.address,
-        amount: import_starknet9.uint256.bnToUint256(
+        amount: import_starknet10.uint256.bnToUint256(
           p.changeAmt.multipliedBy(p.isDeposit ? 1 : -1).toWei()
         )
       });
@@ -10006,10 +10006,10 @@ var VesuRebalance = class _VesuRebalance extends BaseStrategy {
     const avnu = new AvnuWrapper();
     let swapInfo = {
       token_from_address: harvest.token.address,
-      token_from_amount: import_starknet9.uint256.bnToUint256(harvest.actualReward.toWei()),
+      token_from_amount: import_starknet10.uint256.bnToUint256(harvest.actualReward.toWei()),
       token_to_address: this.asset().address.address,
-      token_to_amount: import_starknet9.uint256.bnToUint256(0),
-      token_to_min_amount: import_starknet9.uint256.bnToUint256(0),
+      token_to_amount: import_starknet10.uint256.bnToUint256(0),
+      token_to_min_amount: import_starknet10.uint256.bnToUint256(0),
       beneficiary: this.address.address,
       integrator_fee_amount_bps: 0,
       integrator_fee_recipient: this.address.address,
@@ -10304,7 +10304,7 @@ VesuRebalanceStrategies.forEach((s) => {
 });
 
 // src/strategies/ekubo-cl-vault.tsx
-var import_starknet10 = require("starknet");
+var import_starknet11 = require("starknet");
 
 // src/data/cl-vault.abi.json
 var cl_vault_abi_default = [
@@ -15225,13 +15225,13 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     );
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new import_starknet10.Contract({
+    this.contract = new import_starknet11.Contract({
       abi: cl_vault_abi_default,
       address: this.address.address,
       providerOrAccount: this.config.provider
     });
     if (this.metadata.additionalInfo.lstContract) {
-      this.lstContract = new import_starknet10.Contract({
+      this.lstContract = new import_starknet11.Contract({
         abi: erc4626_abi_default,
         address: this.metadata.additionalInfo.lstContract.address,
         providerOrAccount: this.config.provider
@@ -15240,13 +15240,13 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       this.lstContract = null;
     }
     const EKUBO_POSITION = "0x02e0af29598b407c8716b17f6d2795eca1b471413fa03fb145a5e33722184067";
-    this.ekuboPositionsContract = new import_starknet10.Contract({
+    this.ekuboPositionsContract = new import_starknet11.Contract({
       abi: ekubo_positions_abi_default,
       address: EKUBO_POSITION,
       providerOrAccount: this.config.provider
     });
     const EKUBO_MATH = "0x04a72e9e166f6c0e9d800af4dc40f6b6fb4404b735d3f528d9250808b2481995";
-    this.ekuboMathContract = new import_starknet10.Contract({
+    this.ekuboMathContract = new import_starknet11.Contract({
       abi: ekubo_math_abi_default,
       address: EKUBO_MATH,
       providerOrAccount: this.config.provider
@@ -15277,7 +15277,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     const shares = await this.tokensToShares(amountInfo);
     const { amount0, amount1 } = await this.contract.call(
       "convert_to_assets",
-      [import_starknet10.uint256.bnToUint256(shares.toWei())]
+      [import_starknet11.uint256.bnToUint256(shares.toWei())]
     );
     return {
       token0: {
@@ -15298,27 +15298,27 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
   }
   async depositCall(amountInfo, receiver) {
     const updateAmountInfo = await this.getMinDepositAmounts(amountInfo);
-    const token0Contract = new import_starknet10.Contract({
+    const token0Contract = new import_starknet11.Contract({
       abi: erc4626_abi_default,
       address: amountInfo.token0.tokenInfo.address.address,
       providerOrAccount: this.config.provider
     });
-    const token1Contract = new import_starknet10.Contract({
+    const token1Contract = new import_starknet11.Contract({
       abi: erc4626_abi_default,
       address: amountInfo.token1.tokenInfo.address.address,
       providerOrAccount: this.config.provider
     });
     const call1 = token0Contract.populate("approve", [
       this.address.address,
-      import_starknet10.uint256.bnToUint256(updateAmountInfo.token0.amount.toWei())
+      import_starknet11.uint256.bnToUint256(updateAmountInfo.token0.amount.toWei())
     ]);
     const call2 = token1Contract.populate("approve", [
       this.address.address,
-      import_starknet10.uint256.bnToUint256(updateAmountInfo.token1.amount.toWei())
+      import_starknet11.uint256.bnToUint256(updateAmountInfo.token1.amount.toWei())
     ]);
     const call3 = this.contract.populate("deposit", [
-      import_starknet10.uint256.bnToUint256(updateAmountInfo.token0.amount.toWei()),
-      import_starknet10.uint256.bnToUint256(updateAmountInfo.token1.amount.toWei()),
+      import_starknet11.uint256.bnToUint256(updateAmountInfo.token0.amount.toWei()),
+      import_starknet11.uint256.bnToUint256(updateAmountInfo.token1.amount.toWei()),
       receiver.address
     ]);
     const calls = [];
@@ -15328,8 +15328,8 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
   }
   async tokensToShares(amountInfo) {
     const shares = await this.contract.call("convert_to_shares", [
-      import_starknet10.uint256.bnToUint256(amountInfo.token0.amount.toWei()),
-      import_starknet10.uint256.bnToUint256(amountInfo.token1.amount.toWei())
+      import_starknet11.uint256.bnToUint256(amountInfo.token0.amount.toWei()),
+      import_starknet11.uint256.bnToUint256(amountInfo.token1.amount.toWei())
     ]);
     return Web3Number.fromWei(shares.toString(), 18);
   }
@@ -15340,7 +15340,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     );
     return [
       this.contract.populate("withdraw", [
-        import_starknet10.uint256.bnToUint256(shares.toWei()),
+        import_starknet11.uint256.bnToUint256(shares.toWei()),
         receiver.address
       ])
     ];
@@ -15435,7 +15435,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     let bal = await this.balanceOf(user, blockIdentifier);
     const assets = await this.contract.call(
       "convert_to_assets",
-      [import_starknet10.uint256.bnToUint256(bal.toWei())],
+      [import_starknet11.uint256.bnToUint256(bal.toWei())],
       {
         blockIdentifier
       }
@@ -15580,7 +15580,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       return this.metadata.additionalInfo.truePrice;
     } else if (this.lstContract) {
       const result = await this.lstContract.call("convert_to_assets", [
-        import_starknet10.uint256.bnToUint256(BigInt(1e18).toString())
+        import_starknet11.uint256.bnToUint256(BigInt(1e18).toString())
       ]);
       const truePrice = Number(BigInt(result.toString()) * BigInt(1e9) / BigInt(1e18)) / 1e9;
       return truePrice;
@@ -16034,7 +16034,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     logger.verbose(
       `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
     );
-    const fromAmount = import_starknet10.uint256.uint256ToBN(swapInfo.token_from_amount);
+    const fromAmount = import_starknet11.uint256.uint256ToBN(swapInfo.token_from_amount);
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
     );
@@ -16062,7 +16062,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
             logger.error("Convergence failed: nextAmount <= lowerLimit");
             throw err;
           }
-          newSwapInfo.token_from_amount = import_starknet10.uint256.bnToUint256(nextAmount);
+          newSwapInfo.token_from_amount = import_starknet11.uint256.bnToUint256(nextAmount);
         } else {
           logger.verbose("Increasing swap amount - deficit token0");
           let nextAmount = (fromAmount + upperLimit) / 2n;
@@ -16074,7 +16074,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
             logger.error("Convergence failed: nextAmount >= upperLimit");
             throw err;
           }
-          newSwapInfo.token_from_amount = import_starknet10.uint256.bnToUint256(nextAmount);
+          newSwapInfo.token_from_amount = import_starknet11.uint256.bnToUint256(nextAmount);
         }
       } else if (err.message.includes("invalid token1 amount") || err.message.includes("invalid token1 balance")) {
         if (isSellTokenToken0) {
@@ -16085,7 +16085,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
             logger.error("Convergence failed: nextAmount <= lowerLimit");
             throw err;
           }
-          newSwapInfo.token_from_amount = import_starknet10.uint256.bnToUint256(nextAmount);
+          newSwapInfo.token_from_amount = import_starknet11.uint256.bnToUint256(nextAmount);
         } else {
           logger.verbose("Increasing swap amount - deficit token1");
           let nextAmount = (fromAmount + upperLimit) / 2n;
@@ -16097,13 +16097,13 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
             logger.error("Convergence failed: nextAmount >= upperLimit");
             throw err;
           }
-          newSwapInfo.token_from_amount = import_starknet10.uint256.bnToUint256(nextAmount);
+          newSwapInfo.token_from_amount = import_starknet11.uint256.bnToUint256(nextAmount);
         }
       } else {
         logger.error("Unexpected error:", err);
         throw err;
       }
-      newSwapInfo.token_to_min_amount = import_starknet10.uint256.bnToUint256("0");
+      newSwapInfo.token_to_min_amount = import_starknet11.uint256.bnToUint256("0");
       return this.rebalanceIter(
         newSwapInfo,
         acc,
@@ -16151,15 +16151,15 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     const result = await this.ekuboMathContract.call(
       "liquidity_delta_to_amount_delta",
       [
-        import_starknet10.uint256.bnToUint256(currentPrice.sqrtRatio),
+        import_starknet11.uint256.bnToUint256(currentPrice.sqrtRatio),
         {
           mag: liquidity.toWei(),
           sign: 0
         },
-        import_starknet10.uint256.bnToUint256(
+        import_starknet11.uint256.bnToUint256(
           _EkuboCLVault.priceToSqrtRatio(lowerPrice).toString()
         ),
-        import_starknet10.uint256.bnToUint256(
+        import_starknet11.uint256.bnToUint256(
           _EkuboCLVault.priceToSqrtRatio(upperPrice).toString()
         )
       ],
@@ -16225,15 +16225,15 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       );
       const harvestEstimateCall = async (swapInfo1) => {
         const swap1Amount = Web3Number.fromWei(
-          import_starknet10.uint256.uint256ToBN(swapInfo1.token_from_amount).toString(),
+          import_starknet11.uint256.uint256ToBN(swapInfo1.token_from_amount).toString(),
           18
           // cause its always STRK?
         ).minimum(
           postFeeAmount.toFixed(18)
           // cause always strk
         );
-        swapInfo.token_from_amount = import_starknet10.uint256.bnToUint256(swap1Amount.toWei());
-        swapInfo.token_to_min_amount = import_starknet10.uint256.bnToUint256(
+        swapInfo.token_from_amount = import_starknet11.uint256.bnToUint256(swap1Amount.toWei());
+        swapInfo.token_to_min_amount = import_starknet11.uint256.bnToUint256(
           swap1Amount.multipliedBy(0).toWei()
           // placeholder
         );
@@ -16246,7 +16246,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         );
         const swapInfo2 = {
           ...swapInfo,
-          token_from_amount: import_starknet10.uint256.bnToUint256(remainingAmount.toWei())
+          token_from_amount: import_starknet11.uint256.bnToUint256(remainingAmount.toWei())
         };
         swapInfo2.token_to_address = token1Info.address.address;
         logger.verbose(
@@ -16266,7 +16266,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
             amount: claim.claim.amount.toWei(),
             claimee: claim.claim.claimee.address
           },
-          claim.proof.map((p) => import_starknet10.num.getDecimalString(p)),
+          claim.proof.map((p) => import_starknet11.num.getDecimalString(p)),
           swapInfo,
           swapInfo2
         ];
@@ -16528,7 +16528,7 @@ EkuboCLVaultStrategies.forEach((s) => {
 });
 
 // src/strategies/sensei.ts
-var import_starknet11 = require("starknet");
+var import_starknet12 = require("starknet");
 
 // src/data/sensei.abi.json
 var sensei_abi_default = [
@@ -18303,7 +18303,7 @@ var SenseiVault = class extends BaseStrategy {
     this.address = metadata.address;
     this.pricer = pricer;
     this.metadata = metadata;
-    this.contract = new import_starknet11.Contract({ abi: sensei_abi_default, address: this.address.address, providerOrAccount: this.config.provider });
+    this.contract = new import_starknet12.Contract({ 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");
     }
@@ -18314,7 +18314,7 @@ var SenseiVault = class extends BaseStrategy {
       [user.address]
     );
     const amount = Web3Number.fromWei(
-      import_starknet11.uint256.uint256ToBN(result[1].estimated_size).toString(),
+      import_starknet12.uint256.uint256ToBN(result[1].estimated_size).toString(),
       this.metadata.depositTokens[0].decimals
     );
     const price = await this.pricer.getPrice(
@@ -18355,17 +18355,17 @@ var SenseiVault = class extends BaseStrategy {
     }
   }
   async depositCall(amountInfo, receiver) {
-    const mainTokenContract = new import_starknet11.Contract({
+    const mainTokenContract = new import_starknet12.Contract({
       abi: erc20_abi_default,
       address: this.metadata.depositTokens[0].address.address,
       providerOrAccount: this.config.provider
     });
     const call1 = mainTokenContract.populate("approve", [
       this.address.address,
-      import_starknet11.uint256.bnToUint256(amountInfo.amount.toWei())
+      import_starknet12.uint256.bnToUint256(amountInfo.amount.toWei())
     ]);
     const call2 = this.contract.populate("deposit", [
-      import_starknet11.uint256.bnToUint256(amountInfo.amount.toWei()),
+      import_starknet12.uint256.bnToUint256(amountInfo.amount.toWei()),
       receiver.address
     ]);
     const calls = [call1, call2];
@@ -18373,7 +18373,7 @@ var SenseiVault = class extends BaseStrategy {
   }
   async withdrawCall(amountInfo, receiver, owner) {
     const call = this.contract.populate("withdraw", [
-      import_starknet11.uint256.bnToUint256(amountInfo.amount.toWei()),
+      import_starknet12.uint256.bnToUint256(amountInfo.amount.toWei()),
       receiver.address,
       300
       // 3% max slippage
@@ -18567,7 +18567,7 @@ var SenseiStrategies = [
 ];
 
 // src/strategies/universal-adapters/baseAdapter.ts
-var import_starknet12 = require("starknet");
+var import_starknet13 = require("starknet");
 
 // src/strategies/universal-adapters/adapter-utils.ts
 var SIMPLE_SANITIZER = ContractAddr.from("0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4");
@@ -18588,14 +18588,14 @@ var BaseAdapter = class extends CacheClass {
   constructSimpleLeafData(params) {
     const { id, target, method, packedArguments } = params;
     return {
-      id: BigInt(import_starknet12.num.getDecimalString(import_starknet12.shortString.encodeShortString(id))),
+      id: BigInt(import_starknet13.num.getDecimalString(import_starknet13.shortString.encodeShortString(id))),
       readableId: id,
       data: [
         SIMPLE_SANITIZER.toBigInt(),
         // sanitizer address
         target.toBigInt(),
         // contract
-        toBigInt(import_starknet12.hash.getSelectorFromName(method)),
+        toBigInt(import_starknet13.hash.getSelectorFromName(method)),
         // method name
         BigInt(packedArguments.length),
         ...packedArguments
@@ -18605,7 +18605,7 @@ var BaseAdapter = class extends CacheClass {
 };
 
 // src/strategies/universal-adapters/common-adapter.ts
-var import_starknet13 = require("starknet");
+var import_starknet14 = require("starknet");
 var CommonAdapter = class extends BaseAdapter {
   constructor(config) {
     super();
@@ -18630,12 +18630,12 @@ var CommonAdapter = class extends BaseAdapter {
     return { leaf, callConstructor: this.getFlashloanCall.bind(this) };
   }
   getFlashloanCall(params) {
-    const uint256Amount = import_starknet13.uint256.bnToUint256(params.amount.toWei());
+    const uint256Amount = import_starknet14.uint256.bnToUint256(params.amount.toWei());
     return {
       sanitizer: SIMPLE_SANITIZER,
       call: {
         contractAddress: this.config.manager,
-        selector: import_starknet13.hash.getSelectorFromName("flash_loan"),
+        selector: import_starknet14.hash.getSelectorFromName("flash_loan"),
         calldata: [
           this.config.manager.toBigInt(),
           // receiver
@@ -18669,12 +18669,12 @@ var CommonAdapter = class extends BaseAdapter {
   }
   getApproveCall(token, spender) {
     return (params) => {
-      const uint256Amount = import_starknet13.uint256.bnToUint256(params.amount.toWei());
+      const uint256Amount = import_starknet14.uint256.bnToUint256(params.amount.toWei());
       return {
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: token,
-          selector: import_starknet13.hash.getSelectorFromName("approve"),
+          selector: import_starknet14.hash.getSelectorFromName("approve"),
           calldata: [
             spender.toBigInt(),
             // spender
@@ -18700,12 +18700,12 @@ var CommonAdapter = class extends BaseAdapter {
   }
   getBringLiquidityCall() {
     return (params) => {
-      const uint256Amount = import_starknet13.uint256.bnToUint256(params.amount.toWei());
+      const uint256Amount = import_starknet14.uint256.bnToUint256(params.amount.toWei());
       return {
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: this.config.vaultAddress,
-          selector: import_starknet13.hash.getSelectorFromName("bring_liquidity"),
+          selector: import_starknet14.hash.getSelectorFromName("bring_liquidity"),
           calldata: [
             toBigInt(uint256Amount.low.toString()),
             // amount low
@@ -18737,7 +18737,7 @@ var CommonAdapter = class extends BaseAdapter {
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: AVNU_MIDDLEWARE,
-          selector: import_starknet13.hash.getSelectorFromName("multi_route_swap"),
+          selector: import_starknet14.hash.getSelectorFromName("multi_route_swap"),
           calldata: [
             fromToken.toBigInt(),
             // sell_token_address
@@ -18764,12 +18764,12 @@ var CommonAdapter = class extends BaseAdapter {
             // unpack routes
             BigInt(params.props.routes.length),
             ...params.props.routes.map((r) => [
-              BigInt(import_starknet13.num.hexToDecimalString(r.token_from)),
-              BigInt(import_starknet13.num.hexToDecimalString(r.token_to)),
-              BigInt(import_starknet13.num.hexToDecimalString(r.exchange_address)),
+              BigInt(import_starknet14.num.hexToDecimalString(r.token_from)),
+              BigInt(import_starknet14.num.hexToDecimalString(r.token_to)),
+              BigInt(import_starknet14.num.hexToDecimalString(r.exchange_address)),
               BigInt(r.percent),
               BigInt(r.additional_swap_params.length),
-              ...r.additional_swap_params.map((p) => BigInt(import_starknet13.num.hexToDecimalString(p)))
+              ...r.additional_swap_params.map((p) => BigInt(import_starknet14.num.hexToDecimalString(p)))
             ]).flat()
           ]
         }
@@ -18779,7 +18779,7 @@ var CommonAdapter = class extends BaseAdapter {
 };
 
 // src/strategies/universal-adapters/vesu-adapter.ts
-var import_starknet14 = require("starknet");
+var import_starknet15 = require("starknet");
 
 // src/data/vesu-singleton.abi.json
 var vesu_singleton_abi_default = [
@@ -21075,7 +21075,7 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         amount_type: this.formatAmountTypeEnum(params.collateralAmount.amount_type),
         denomination: this.formatAmountDenominationEnum(params.collateralAmount.denomination),
         value: {
-          abs: import_starknet14.uint256.bnToUint256(params.collateralAmount.value.abs.toWei()),
+          abs: import_starknet15.uint256.bnToUint256(params.collateralAmount.value.abs.toWei()),
           is_negative: params.collateralAmount.value.abs.isZero() ? false : params.collateralAmount.value.is_negative
         }
       };
@@ -21084,12 +21084,12 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         amount_type: this.formatAmountTypeEnum(params.debtAmount.amount_type),
         denomination: this.formatAmountDenominationEnum(params.debtAmount.denomination),
         value: {
-          abs: import_starknet14.uint256.bnToUint256(params.debtAmount.value.abs.toWei()),
+          abs: import_starknet15.uint256.bnToUint256(params.debtAmount.value.abs.toWei()),
           is_negative: params.debtAmount.value.abs.isZero() ? false : params.debtAmount.value.is_negative
         }
       };
       logger.verbose(`VesuAdapter::ConstructingModify::Debt::${JSON.stringify(_debt)}`);
-      const singletonContract = new import_starknet14.Contract({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.toString(), providerOrAccount: new import_starknet14.RpcProvider({ nodeUrl: "" }) });
+      const singletonContract = new import_starknet15.Contract({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.toString(), providerOrAccount: new import_starknet15.RpcProvider({ nodeUrl: "" }) });
       const call = singletonContract.populate("modify_position", {
         params: {
           pool_id: this.config.poolId.toBigInt(),
@@ -21105,7 +21105,7 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: this.VESU_SINGLETON,
-          selector: import_starknet14.hash.getSelectorFromName("modify_position"),
+          selector: import_starknet15.hash.getSelectorFromName("modify_position"),
           calldata: [
             ...call.calldata
           ]
@@ -21116,14 +21116,14 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
       return () => {
         const packedArguments = [];
         const output = {
-          id: BigInt(import_starknet14.num.getDecimalString(import_starknet14.shortString.encodeShortString(id))),
+          id: BigInt(import_starknet15.num.getDecimalString(import_starknet15.shortString.encodeShortString(id))),
           readableId: id,
           data: [
             SIMPLE_SANITIZER.toBigInt(),
             // sanitizer address
             VESU_REWARDS_CONTRACT.toBigInt(),
             // contract
-            toBigInt(import_starknet14.hash.getSelectorFromName("claim")),
+            toBigInt(import_starknet15.hash.getSelectorFromName("claim")),
             // method name
             BigInt(packedArguments.length),
             ...packedArguments
@@ -21137,11 +21137,11 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: VESU_REWARDS_CONTRACT,
-          selector: import_starknet14.hash.getSelectorFromName("claim"),
+          selector: import_starknet15.hash.getSelectorFromName("claim"),
           calldata: [
             BigInt(params.amount.toWei()),
             BigInt(params.proofs.length),
-            ...params.proofs.map((proof) => BigInt(import_starknet14.num.hexToDecimalString(proof)))
+            ...params.proofs.map((proof) => BigInt(import_starknet15.num.hexToDecimalString(proof)))
           ]
         }
       });
@@ -21171,23 +21171,23 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
   formatAmountTypeEnum(amountType) {
     switch (amountType) {
       case 0 /* Delta */:
-        return new import_starknet14.CairoCustomEnum({ Delta: {} });
+        return new import_starknet15.CairoCustomEnum({ Delta: {} });
       case 1 /* Target */:
-        return new import_starknet14.CairoCustomEnum({ Target: {} });
+        return new import_starknet15.CairoCustomEnum({ Target: {} });
     }
     throw new Error(`Unknown VesuAmountType: ${amountType}`);
   }
   formatAmountDenominationEnum(denomination) {
     switch (denomination) {
       case 0 /* Native */:
-        return new import_starknet14.CairoCustomEnum({ Native: {} });
+        return new import_starknet15.CairoCustomEnum({ Native: {} });
       case 1 /* Assets */:
-        return new import_starknet14.CairoCustomEnum({ Assets: {} });
+        return new import_starknet15.CairoCustomEnum({ Assets: {} });
     }
     throw new Error(`Unknown VesuAmountDenomination: ${denomination}`);
   }
   getVesuSingletonContract(config) {
-    return new import_starknet14.Contract({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.address, providerOrAccount: config.provider });
+    return new import_starknet15.Contract({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.address, providerOrAccount: config.provider });
   }
   async getLTVConfig(config) {
     const CACHE_KEY = "ltv_config";
@@ -21328,7 +21328,7 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
 };
 
 // src/strategies/universal-strategy.tsx
-var import_starknet15 = require("starknet");
+var import_starknet16 = require("starknet");
 
 // src/data/universal-vault.abi.json
 var universal_vault_abi_default = [
@@ -23550,12 +23550,12 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     );
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new import_starknet15.Contract({
+    this.contract = new import_starknet16.Contract({
       abi: universal_vault_abi_default,
       address: this.address.address,
       providerOrAccount: this.config.provider
     });
-    this.managerContract = new import_starknet15.Contract({
+    this.managerContract = new import_starknet16.Contract({
       abi: vault_manager_abi_default,
       address: this.metadata.additionalInfo.manager.address,
       providerOrAccount: this.config.provider
@@ -23609,17 +23609,17 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Deposit token mismatch"
     );
-    const assetContract = new import_starknet15.Contract({
+    const assetContract = new import_starknet16.Contract({
       abi: universal_vault_abi_default,
       address: this.asset().address.address,
       providerOrAccount: this.config.provider
     });
     const call1 = assetContract.populate("approve", [
       this.address.address,
-      import_starknet15.uint256.bnToUint256(amountInfo.amount.toWei())
+      import_starknet16.uint256.bnToUint256(amountInfo.amount.toWei())
     ]);
     const call2 = this.contract.populate("deposit", [
-      import_starknet15.uint256.bnToUint256(amountInfo.amount.toWei()),
+      import_starknet16.uint256.bnToUint256(amountInfo.amount.toWei()),
       receiver.address
     ]);
     return [call1, call2];
@@ -23629,9 +23629,9 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Withdraw token mismatch"
     );
-    const shares = await this.contract.call("convert_to_shares", [import_starknet15.uint256.bnToUint256(amountInfo.amount.toWei())]);
+    const shares = await this.contract.call("convert_to_shares", [import_starknet16.uint256.bnToUint256(amountInfo.amount.toWei())]);
     const call = this.contract.populate("request_redeem", [
-      import_starknet15.uint256.bnToUint256(shares.toString()),
+      import_starknet16.uint256.bnToUint256(shares.toString()),
       receiver.address,
       owner.address
     ]);
@@ -23645,7 +23645,7 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
   async getUserTVL(user) {
     const shares = await this.contract.balanceOf(user.address);
     const assets = await this.contract.convert_to_assets(
-      import_starknet15.uint256.bnToUint256(shares)
+      import_starknet16.uint256.bnToUint256(shares)
     );
     const amount = Web3Number.fromWei(
       assets.toString(),
@@ -23668,8 +23668,8 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
   async netAPY() {
     const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
     const pools = await VesuAdapter.getVesuPools();
-    const pool1 = pools.pools.find((p) => vesuAdapter1.config.poolId.eqString(import_starknet15.num.getHexString(p.id)));
-    const pool2 = pools.pools.find((p) => vesuAdapter2.config.poolId.eqString(import_starknet15.num.getHexString(p.id)));
+    const pool1 = pools.pools.find((p) => vesuAdapter1.config.poolId.eqString(import_starknet16.num.getHexString(p.id)));
+    const pool2 = pools.pools.find((p) => vesuAdapter2.config.poolId.eqString(import_starknet16.num.getHexString(p.id)));
     if (!pool1 || !pool2) {
       throw new Error("Pool not found");
     }
@@ -23813,7 +23813,7 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     return [...leg1Positions, ...leg2Positions];
   }
   getSetManagerCall(strategist, root = this.getMerkleRoot()) {
-    return this.managerContract.populate("set_manage_root", [strategist.address, import_starknet15.num.getHexString(root)]);
+    return this.managerContract.populate("set_manage_root", [strategist.address, import_starknet16.num.getHexString(root)]);
   }
   getManageCall(proofIds, manageCalls) {
     assert(proofIds.length == manageCalls.length, "Proof IDs and Manage Calls length mismatch");
@@ -23990,7 +23990,7 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       callSet1 = [...temp];
     }
     const allActions = [...callSet1.map((i) => i.manageCall), ...callSet2.map((i) => i.manageCall)];
-    const flashloanCalldata = import_starknet15.CallData.compile([
+    const flashloanCalldata = import_starknet16.CallData.compile([
       [...callSet1.map((i) => i.proofs), ...callSet2.map((i) => i.proofs)],
       allActions.map((i) => i.sanitizer.address),
       allActions.map((i) => i.call.contractAddress.address),
@@ -24552,12 +24552,12 @@ var PricerRedis = class extends Pricer {
 
 // src/node/deployer.ts
 var import_assert = __toESM(require("assert"));
-var import_starknet17 = require("starknet");
+var import_starknet18 = require("starknet");
 var import_fs2 = require("fs");
 
 // src/utils/store.ts
 var import_fs = __toESM(require("fs"));
-var import_starknet16 = require("starknet");
+var import_starknet17 = require("starknet");
 var crypto2 = __toESM(require("crypto"));
 
 // src/utils/encrypt.ts
@@ -24651,7 +24651,7 @@ var Store = class _Store {
     }
     logger.verbose(`Account loaded: ${accountKey} from network: ${this.config.network}`);
     logger.verbose(`Address: ${data.address}`);
-    const acc = new import_starknet16.Account({
+    const acc = new import_starknet17.Account({
       provider: this.config.provider,
       address: data.address,
       signer: data.pk,
@@ -24746,10 +24746,10 @@ function getAccount(accountKey, config, password = process.env.ACCOUNT_SECURE_PA
 }
 async function myDeclare(contract_name, package_name = "strkfarm", config, acc) {
   const provider2 = config.provider;
-  const compiledSierra = import_starknet17.json.parse(
+  const compiledSierra = import_starknet18.json.parse(
     (0, import_fs2.readFileSync)(`./target/release/${package_name}_${contract_name}.contract_class.json`).toString("ascii")
   );
-  const compiledCasm = import_starknet17.json.parse(
+  const compiledCasm = import_starknet18.json.parse(
     (0, import_fs2.readFileSync)(`./target/release/${package_name}_${contract_name}.compiled_contract_class.json`).toString("ascii")
   );
   const contracts = getContracts();
@@ -24757,7 +24757,7 @@ async function myDeclare(contract_name, package_name = "strkfarm", config, acc)
     contract: compiledSierra,
     casm: compiledCasm
   };
-  const result = (0, import_starknet17.extractContractHashes)(payload);
+  const result = (0, import_starknet18.extractContractHashes)(payload);
   console.log("classhash:", result.classHash);
   try {
     const cls = await provider2.getClassByHash(result.classHash);
@@ -24775,7 +24775,7 @@ async function myDeclare(contract_name, package_name = "strkfarm", config, acc)
   const tx = await acc.declareIfNot(payload);
   console.log(`Declaring: ${contract_name}, tx:`, tx.transaction_hash);
   await provider2.waitForTransaction(tx.transaction_hash, {
-    successStates: [import_starknet17.TransactionExecutionStatus.SUCCEEDED]
+    successStates: [import_starknet18.TransactionExecutionStatus.SUCCEEDED]
   });
   if (!contracts.class_hashes) {
     contracts["class_hashes"] = {};
@@ -24799,7 +24799,7 @@ async function deployContract(contract_name, classHash, constructorData, config,
   });
   console.log("Deploy tx: ", tx.transaction_hash);
   await provider2.waitForTransaction(tx.transaction_hash, {
-    successStates: [import_starknet17.TransactionExecutionStatus.SUCCEEDED]
+    successStates: [import_starknet18.TransactionExecutionStatus.SUCCEEDED]
   });
   const contracts = getContracts();
   if (!contracts.contracts) {
@@ -24816,7 +24816,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 } = new import_starknet17.Deployer().buildDeployerCall({
+    const { calls, addresses } = new import_starknet18.Deployer().buildDeployerCall({
       classHash,
       constructorCalldata: constructorData
     }, acc.address);
@@ -24834,7 +24834,7 @@ async function prepareMultiDeployContracts(contracts, config, acc) {
 }
 async function executeDeployCalls(contractsInfo, acc, provider2) {
   for (let contractInfo of contractsInfo) {
-    (0, import_assert.default)(import_starknet17.num.toHexString(contractInfo.call.contractAddress) == import_starknet17.num.toHexString(import_starknet17.constants.UDC.ADDRESS), "Must be pointed at UDC address");
+    (0, import_assert.default)(import_starknet18.num.toHexString(contractInfo.call.contractAddress) == import_starknet18.num.toHexString(import_starknet18.constants.UDC.ADDRESS), "Must be pointed at UDC address");
   }
   const allCalls = contractsInfo.map((info) => info.call);
   await executeTransactions(allCalls, acc, provider2, `Deploying contracts: ${contractsInfo.map((info) => info.contract_name).join(", ")}`);
@@ -24858,7 +24858,7 @@ async function executeTransactions(calls, acc, provider2, remarks) {
   if (remarks)
     console.log(`Remarks: ${remarks}`);
   await provider2.waitForTransaction(tx.transaction_hash, {
-    successStates: [import_starknet17.TransactionExecutionStatus.SUCCEEDED]
+    successStates: [import_starknet18.TransactionExecutionStatus.SUCCEEDED]
   });
   console.log(`Transaction confirmed: ${tx.transaction_hash}`);
   return tx;

package/dist/index.mjs

@@ -1982,7 +1982,7 @@ import { processMultiProof, processProof } from "@ericnordelo/strk-merkle-tree/d
 import { standardLeafHash } from "@ericnordelo/strk-merkle-tree/dist/hashes";
 import { MerkleTreeImpl } from "@ericnordelo/strk-merkle-tree/dist/merkletree";
 import { num as num2 } from "starknet";
-import * as starknet from "@scure/starknet";
+import { pedersen } from "@scure/starknet";
 function hash_leaf(leaf) {
   if (leaf.data.length < 1) {
     throw new Error("Invalid leaf data");
@@ -1995,7 +1995,7 @@ function hash_leaf(leaf) {
   return `0x${num2.toHexString(value).replace(/^0x/, "").padStart(64, "0")}`;
 }
 function pedersen_hash(a, b) {
-  return BigInt(starknet.pedersen(a, b).toString());
+  return BigInt(pedersen(a, b).toString());
 }
 var StandardMerkleTree = class _StandardMerkleTree extends MerkleTreeImpl {
   constructor(tree, values, leafEncoding) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "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",

package/src/utils/oz-merkle.ts

@@ -6,7 +6,7 @@ import { MerkleTreeOptions } from "@ericnordelo/strk-merkle-tree/dist/options";
 import { ValueType } from "@ericnordelo/strk-merkle-tree/dist/serde";
 import { validateArgument } from "@ericnordelo/strk-merkle-tree/src/utils/errors";
 import { num } from "starknet";
-import * as starknet from "@scure/starknet";
+import { pedersen } from "@scure/starknet";
 
 export interface LeafData {
   id: bigint,
@@ -27,7 +27,7 @@ function hash_leaf(leaf: LeafData) {
 }
 
 function pedersen_hash(a: bigint, b: bigint): bigint {
-  return BigInt(starknet.pedersen(a, b).toString());
+  return BigInt(pedersen(a, b).toString());
 }