@strkfarm/sdk 1.1.50 → 1.1.52

package/dist/index.mjs

@@ -2165,10 +2165,9 @@ function getTrovesEndpoint() {
 }
 
 // src/modules/avnu.ts
-var AvnuWrapper = class _AvnuWrapper {
+var AvnuWrapper = class {
   async getQuotes(fromToken, toToken, amountWei, taker, retry = 0, excludeSources = ["Haiko(Solvers)"]) {
     const MAX_RETRY = 5;
-    logger.verbose(`${_AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
     const params = {
       sellTokenAddress: fromToken,
       buyTokenAddress: toToken,
@@ -2211,9 +2210,6 @@ var AvnuWrapper = class _AvnuWrapper {
       startIndex += 5 + swap_params_len;
     }
     const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
-    logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
-    logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
-    logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo = {
       token_from_address: quote.sellTokenAddress,
       token_from_amount: uint256.bnToUint256(quote.sellAmount),
@@ -4034,20 +4030,26 @@ var Harvests = class _Harvests {
     const rewards = await this.getHarvests(addr);
     if (rewards.length == 0) return [];
     const unClaimed = [];
-    const reward = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime())[0];
-    const cls = await this.config.provider.getClassAt(reward.rewardsContract.address);
-    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) {
-      return unClaimed;
+    const sortedRewards = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
+    if (sortedRewards.length == 0) {
+      logger.verbose(`${_Harvests.name}: no rewards found`);
+      return [];
     }
-    const bal = await new ERC20(this.config).balanceOf(reward.token, reward.rewardsContract.address, 18);
-    if (bal.lessThan(reward.claim.amount)) {
-      logger.verbose(`${_Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
-      return unClaimed;
+    const cls = await this.config.provider.getClassAt(sortedRewards[0].rewardsContract.address);
+    for (const reward of sortedRewards) {
+      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}, claim id: ${reward.claim.id}, address: ${reward.rewardsContract.address}`);
+      if (isClaimed) {
+        continue;
+      }
+      const bal = await new ERC20(this.config).balanceOf(reward.token, reward.rewardsContract.address, 18);
+      if (bal.lessThan(reward.claim.amount)) {
+        logger.verbose(`${_Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
+        continue;
+      }
+      unClaimed.push(reward);
     }
-    unClaimed.unshift(reward);
     return unClaimed;
   }
 };
@@ -16538,11 +16540,15 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       amount1
     };
   }
-  async harvest(acc, maxIterations = 20, priceRatioPrecision = 4) {
+  async harvest(acc, maxIterations = 20, priceRatioPrecision = 4, minRewardAmount = new Web3Number(0, 18)) {
     const ekuboHarvests = new EkuboHarvests(this.config);
-    const unClaimedRewards = await ekuboHarvests.getUnHarvestedRewards(
+    const unClaimedRewards = (await ekuboHarvests.getUnHarvestedRewards(
       this.address
-    );
+    )).filter((claim) => claim.actualReward.greaterThanOrEqualTo(minRewardAmount));
+    if (unClaimedRewards.length == 0) {
+      logger.verbose(`${_EkuboCLVault.name}: harvest => no unclaimed rewards found`);
+      return [];
+    }
     const poolKey = await this.getPoolKey();
     const token0Info = await Global.getTokenInfoFromAddr(poolKey.token0);
     const token1Info = await Global.getTokenInfoFromAddr(poolKey.token1);
@@ -16551,7 +16557,10 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       `${_EkuboCLVault.name}: harvest => unClaimedRewards: ${unClaimedRewards.length}`
     );
     const calls = [];
-    for (let claim of unClaimedRewards) {
+    const chosenClaim = unClaimedRewards[0];
+    logger.info(`${_EkuboCLVault.name}: harvest => doing one at a time`);
+    logger.info(`${_EkuboCLVault.name}: harvest => chosenClaim -> Claim ID: ${chosenClaim.claim.id}, Amount: ${chosenClaim.claim.amount.toString()}, actualAmount: ${chosenClaim.actualReward.toString()}, addr: ${chosenClaim.claim.claimee.toString()}`);
+    for (let claim of [chosenClaim]) {
       const fee = claim.claim.amount.multipliedBy(this.metadata.additionalInfo.feeBps).dividedBy(1e4);
       const postFeeAmount = claim.claim.amount.minus(fee);
       const isToken1 = claim.token.eq(poolKey.token1);
@@ -16600,57 +16609,41 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     const token0Amt = isToken1 ? new Web3Number(0, token0Info.decimals) : postFeeAmount;
     const token1Amt = isToken1 ? postFeeAmount : new Web3Number(0, token0Info.decimals);
     logger.verbose(
-      `${_EkuboCLVault.name}: harvest => token0Amt: ${token0Amt.toString()}, token1Amt: ${token1Amt.toString()}`
-    );
-    const swapInfo = await this.getSwapInfoGivenAmounts(
-      poolKey,
-      token0Amt,
-      token1Amt,
-      bounds,
-      maxIterations,
-      priceRatioPrecision
-    );
-    swapInfo.token_to_address = token0Info.address.address;
-    logger.verbose(
-      `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(swapInfo)}`
+      `${_EkuboCLVault.name}: harvest => token0Amt: ${token0Amt.toFixed(18)}, token1Amt: ${token1Amt.toFixed(18)}`
     );
     logger.verbose(
       `${_EkuboCLVault.name}: harvest => claim: ${JSON.stringify(claim)}`
     );
-    const harvestEstimateCall = async (swapInfo1) => {
-      const swap1Amount = Web3Number.fromWei(
-        uint2564.uint256ToBN(swapInfo1.token_from_amount).toString(),
-        18
-        // cause its always STRK?
+    const claimTokenInfo = await Global.getTokenInfoFromAddr(claim.token);
+    const harvestEstimateCall = async (baseSwapInfo2) => {
+      let baseSwapAmount = Web3Number.fromWei(
+        uint2564.uint256ToBN(baseSwapInfo2.token_from_amount).toString(),
+        claimTokenInfo.decimals
       ).minimum(
-        postFeeAmount.toFixed(18)
-        // cause always strk
-      );
-      swapInfo.token_from_amount = uint2564.bnToUint256(swap1Amount.toWei());
-      swapInfo.token_to_min_amount = uint2564.bnToUint256(
-        swap1Amount.multipliedBy(0).toWei()
-        // placeholder
+        postFeeAmount.toFixed(claimTokenInfo.decimals)
       );
+      if (baseSwapAmount.lt(1e-4)) {
+        baseSwapAmount = new Web3Number(0, claimTokenInfo.decimals);
+      }
+      baseSwapInfo2.token_from_amount = uint2564.bnToUint256(baseSwapAmount.toWei());
+      const isToken0ClaimToken2 = claim.token.eq(poolKey.token0);
       logger.verbose(
-        `${_EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
+        `${_EkuboCLVault.name}: harvest => isToken0ClaimToken: ${isToken0ClaimToken2}, baseSwapAmount: ${baseSwapAmount}`
       );
-      const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
+      const remainingAmount = postFeeAmount.minus(baseSwapAmount).maximum(0);
       logger.verbose(
         `${_EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
       );
-      const swapInfo2 = {
-        ...swapInfo,
-        token_from_amount: uint2564.bnToUint256(remainingAmount.toWei())
-      };
-      swapInfo2.token_to_address = token1Info.address.address;
+      let dummySwapInfo = AvnuWrapper.buildZeroSwap(claim.token, this.address.address, claim.token);
+      dummySwapInfo.token_from_amount = uint2564.bnToUint256(remainingAmount.toWei());
       logger.verbose(
-        `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
-          swapInfo
+        `${_EkuboCLVault.name}: harvest => dummySwapInfo: ${JSON.stringify(
+          dummySwapInfo
         )}`
       );
       logger.verbose(
-        `${_EkuboCLVault.name}: harvest => swapInfo2: ${JSON.stringify(
-          swapInfo2
+        `${_EkuboCLVault.name}: harvest => baseSwapInfo: ${JSON.stringify(
+          baseSwapInfo2
         )}`
       );
       const calldata = [
@@ -16661,18 +16654,36 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           claimee: claim.claim.claimee.address
         },
         claim.proof.map((p) => num5.getDecimalString(p)),
-        swapInfo,
-        swapInfo2
+        isToken0ClaimToken2 ? dummySwapInfo : baseSwapInfo2,
+        // is token0 claim token, its just dummy swap
+        isToken0ClaimToken2 ? baseSwapInfo2 : dummySwapInfo
       ];
-      logger.verbose(
-        `${_EkuboCLVault.name}: harvest => calldata: ${JSON.stringify(
-          calldata
-        )}`
-      );
       return [this.contract.populate("harvest", calldata)];
     };
+    const isToken0ClaimToken = claim.token.eq(poolKey.token0);
+    let baseSwapInfo = AvnuWrapper.buildZeroSwap(claim.token, this.address.address, isToken0ClaimToken ? token1Info.address : token0Info.address);
+    baseSwapInfo.token_from_amount = uint2564.bnToUint256(postFeeAmount.toWei());
+    if (postFeeAmount.greaterThan(0) && !isToken0ClaimToken) {
+      const avnuWrapper = new AvnuWrapper();
+      const quote = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token0Info.address.address,
+        postFeeAmount.toWei(),
+        this.address.address
+      );
+      baseSwapInfo = await avnuWrapper.getSwapInfo(quote, this.address.address, 0, this.address.address);
+    } else if (postFeeAmount.greaterThan(0) && isToken0ClaimToken) {
+      const avnuWrapper = new AvnuWrapper();
+      const quote = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token1Info.address.address,
+        postFeeAmount.toWei(),
+        this.address.address
+      );
+      baseSwapInfo = await avnuWrapper.getSwapInfo(quote, this.address.address, 0, this.address.address);
+    }
     const _callsFinal = await this.rebalanceIter(
-      swapInfo,
+      baseSwapInfo,
       acc,
       harvestEstimateCall,
       claim.token.eq(poolKey.token0),
@@ -16716,32 +16727,40 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
   async harvestMismatchEstimateCallFn(params) {
     const { postFeeAmount, claim, token0Info, token1Info, acc } = params;
     let harvestCall = null;
+    logger.verbose(`${_EkuboCLVault.name}: harvestMismatchEstimateCallFn => postFeeAmount: ${postFeeAmount.toString()}`);
+    let attempt = 0;
+    let MAX_ATTEMPTS = 50;
     const binarySearchCallbackFn = async (mid) => {
+      attempt++;
+      logger.verbose(`${_EkuboCLVault.name}: harvestMismatchEstimateCallFn => mid: ${mid}, attempt: ${attempt}/${MAX_ATTEMPTS}`);
       const rewardPart2 = BigInt(postFeeAmount.toWei()) - mid;
       const avnuWrapper = new AvnuWrapper();
       const beneficiary = this.address.address;
-      const quote1 = await avnuWrapper.getQuotes(
+      const quote1Prom = avnuWrapper.getQuotes(
         claim.token.address,
         token0Info.address.address,
         mid.toString(),
         beneficiary
       );
+      const quote2Prom = avnuWrapper.getQuotes(
+        claim.token.address,
+        token1Info.address.address,
+        rewardPart2.toString(),
+        beneficiary
+      );
+      const [quote1, quote2] = await Promise.all([quote1Prom, quote2Prom]);
       const swapInfo1 = await avnuWrapper.getSwapInfo(
         quote1,
         beneficiary,
         0,
-        beneficiary
-      );
-      const quote2 = await avnuWrapper.getQuotes(
-        claim.token.address,
-        token1Info.address.address,
-        rewardPart2.toString(),
+        // fee bps
         beneficiary
       );
       const swapInfo2 = await avnuWrapper.getSwapInfo(
         quote2,
         beneficiary,
         0,
+        // fee bps
         beneficiary
       );
       try {
@@ -16758,13 +16777,17 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         ];
         harvestCall = this.contract.populate("harvest", calldata);
         const gas = await acc.estimateInvokeFee(harvestCall);
+        logger.verbose(`${_EkuboCLVault.name}: harvestMismatchEstimateCallFn => gas: ${gas.overall_fee.toString()}, attempt: ${attempt}/${MAX_ATTEMPTS}`);
         return "found";
       } catch (err) {
         if (err.message.includes("invalid token0 amount")) {
+          logger.verbose(`${_EkuboCLVault.name}: harvestMismatchEstimateCallFn => invalid token0 amount, attempt: ${attempt}/${MAX_ATTEMPTS}`);
           return "go_low";
         } else if (err.message.includes("invalid token1 amount")) {
+          logger.verbose(`${_EkuboCLVault.name}: harvestMismatchEstimateCallFn => invalid token1 amount, attempt: ${attempt}/${MAX_ATTEMPTS}`);
           return "go_high";
         }
+        logger.verbose(`${_EkuboCLVault.name}: harvestMismatchEstimateCallFn => error: ${err.message}, attempt: ${attempt}/${MAX_ATTEMPTS}`);
         return "retry";
       }
     };
@@ -30923,6 +30946,7 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
    * @param params 
    */
   async getVesuMultiplyCall(params) {
+    const maxEkuboPriceImpact = params.maxEkuboPriceImpact || 0.01;
     const vesuAdapter1 = this.getVesuSameTokenAdapter();
     const legLTV = await vesuAdapter1.getLTVConfig(this.config);
     logger.verbose(`${this.getTag()}::getVesuMultiplyCall legLTV: ${legLTV}`);
@@ -30958,7 +30982,8 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
       marginAmount,
       debtAmount,
       lstDexPriceInUnderlying: dexPrice,
-      isIncrease: debtAmount.greaterThan(0)
+      isIncrease: debtAmount.greaterThan(0),
+      maxEkuboPriceImpact
     });
   }
   getLSTUnderlyingTokenInfo() {
@@ -31135,7 +31160,7 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
       // negative for exact amount out
     );
     logger.verbose(`${this.getTag()}::getModifyLeverCall leverSwapQuote: ${JSON.stringify(leverSwapQuote)}`);
-    assert(leverSwapQuote.price_impact < 0.01, "getIncreaseLeverCall: Price impact is too high [Debt swap]");
+    assert(leverSwapQuote.price_impact <= params.maxEkuboPriceImpact, "getIncreaseLeverCall: Price impact is too high [Debt swap]");
     const leverSwap = ekuboQuoter.getVesuMultiplyQuote(leverSwapQuote, fromToken, toToken);
     logger.verbose(`${this.getTag()}::getModifyLeverCall leverSwap: ${JSON.stringify(leverSwap)}`);
     let minLSTReceived = params.debtAmount.dividedBy(lstDexPriceInUnderlying).multipliedBy(1 - MAX_SLIPPAGE);
@@ -32118,13 +32143,42 @@ async function executeTransactions(calls, acc, provider2, remarks) {
   console.log(`Transaction confirmed: ${tx.transaction_hash}`);
   return tx;
 }
+async function myWaitForTransaction(transaction_hash, provider2, retry = 0) {
+  const MAX_RETRIES = 60;
+  logger.verbose(`Waiting for transaction: ${transaction_hash}, retry: ${retry}`);
+  try {
+    const status = await provider2.getTransactionStatus(transaction_hash);
+    logger.verbose(`Transaction status: ${JSON.stringify(status.execution_status)}`);
+    if (status.execution_status == TransactionExecutionStatus.SUCCEEDED) {
+      return true;
+    }
+    if (status.execution_status == TransactionExecutionStatus.REVERTED) {
+      throw new Error(`Transaction reverted: ${transaction_hash}`);
+    }
+    if (retry > MAX_RETRIES) {
+      throw new Error(`Transaction not found: ${transaction_hash}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    return myWaitForTransaction(transaction_hash, provider2, retry + 1);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Transaction reverted")) {
+      throw new Error(`Transaction reverted: ${transaction_hash}`);
+    }
+    if (retry > MAX_RETRIES) {
+      throw error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    return myWaitForTransaction(transaction_hash, provider2, retry + 1);
+  }
+}
 var Deployer = {
   getAccount,
   myDeclare,
   deployContract,
   prepareMultiDeployContracts,
   executeDeployCalls,
-  executeTransactions
+  executeTransactions,
+  myWaitForTransaction
 };
 var deployer_default = Deployer;
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.1.50",
+  "version": "1.1.52",
   "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/modules/avnu.ts

@@ -37,7 +37,7 @@ export class AvnuWrapper {
     excludeSources = ['Haiko(Solvers)']
   ): Promise<Quote> {
     const MAX_RETRY = 5;
-    logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
+    // logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
     const params: any = {
       sellTokenAddress: fromToken,
       buyTokenAddress: toToken,
@@ -100,9 +100,9 @@ export class AvnuWrapper {
     // swapInfo as expected by the strategy
     // fallback, max 1% slippage
     const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo: SwapInfo = {
       token_from_address: quote.sellTokenAddress,
       token_from_amount: uint256.bnToUint256(quote.sellAmount),

package/src/modules/harvests.ts

@@ -34,23 +34,30 @@ export class Harvests {
         const unClaimed: HarvestInfo[] = [];
 
         // use the latest one
-        const reward = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime())[0];
-
-        const cls = await this.config.provider.getClassAt(reward.rewardsContract.address);
-        const contract = new 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) {
-            return unClaimed;
-        }
-        // rewards contract must have enough balance to claim
-        const bal = await (new ERC20(this.config)).balanceOf(reward.token, reward.rewardsContract.address, 18);
-        if (bal.lessThan(reward.claim.amount)) {
-            logger.verbose(`${Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
-            return unClaimed;
+        const sortedRewards = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
+        if (sortedRewards.length == 0) {
+            logger.verbose(`${Harvests.name}: no rewards found`);
+            return [];
         }
 
-        unClaimed.unshift(reward); // to ensure older harvest is first
+        const cls = await this.config.provider.getClassAt(sortedRewards[0].rewardsContract.address);
+
+        for (const reward of sortedRewards) {
+            const contract = new 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}, claim id: ${reward.claim.id}, address: ${reward.rewardsContract.address}`);
+            if (isClaimed) {
+                continue;
+            }
+            // rewards contract must have enough balance to claim
+            const bal = await (new ERC20(this.config)).balanceOf(reward.token, reward.rewardsContract.address, 18);
+            if (bal.lessThan(reward.claim.amount)) {
+                logger.verbose(`${Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
+                continue;
+            }
+
+            unClaimed.push(reward); // to ensure older harvest is first
+        }
         return unClaimed;
     }
 }

package/src/node/deployer.ts

@@ -4,6 +4,7 @@ import { readFileSync, existsSync, writeFileSync } from 'fs'
 import { IConfig } from '../interfaces';
 import { Store, getDefaultStoreConfig } from '../utils/store';
 import { add } from 'winston';
+import { logger } from '@/utils';
 
 function getContracts() {
     const PATH = './contracts.json'
@@ -207,13 +208,47 @@ async function executeTransactions(
     return tx;
 }
 
+async function myWaitForTransaction(
+    transaction_hash: string,
+    provider: RpcProvider,
+    retry = 0
+) {
+    const MAX_RETRIES = 60;
+    logger.verbose(`Waiting for transaction: ${transaction_hash}, retry: ${retry}`);
+    try {
+        const status = await provider.getTransactionStatus(transaction_hash);
+        logger.verbose(`Transaction status: ${JSON.stringify(status.execution_status)}`);
+        if (status.execution_status == TransactionExecutionStatus.SUCCEEDED) {
+            return true;
+        }
+        if (status.execution_status == TransactionExecutionStatus.REVERTED) {
+            throw new Error(`Transaction reverted: ${transaction_hash}`);
+        }
+        if (retry > MAX_RETRIES) {
+            throw new Error(`Transaction not found: ${transaction_hash}`);
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return myWaitForTransaction(transaction_hash, provider, retry + 1);
+    } catch (error) {
+        if (error instanceof Error && error.message.includes('Transaction reverted')) {
+            throw new Error(`Transaction reverted: ${transaction_hash}`);
+        }
+        if (retry > MAX_RETRIES) {
+            throw error;
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return myWaitForTransaction(transaction_hash, provider, retry + 1);
+    }
+}
+
 const Deployer = {
     getAccount,
     myDeclare,
     deployContract,
     prepareMultiDeployContracts,
     executeDeployCalls,
-    executeTransactions
+    executeTransactions,
+    myWaitForTransaction
 }
 
 export default Deployer;