@strkfarm/sdk 2.0.0-dev.8 → 2.0.0-dev.9

package/dist/index.browser.global.js

@@ -94315,32 +94315,101 @@ spurious results.`);
       }
     }
     async getDepositOrWithdrawalStatus(orderId, operationsType) {
-      try {
-        let transferHistory = await this.client.getAssetOperations({
-          operationsType: [operationsType],
-          operationsStatus: ["COMPLETED" /* COMPLETED */]
-        });
-        if (operationsType === "DEPOSIT" /* DEPOSIT */) {
-          const myTransferStatus = transferHistory.data.find(
-            (operation) => operation.transactionHash === orderId
-          );
-          if (!myTransferStatus) {
-            return true;
+      const maxAttempts = 5;
+      const retryDelayMs = 3e4;
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+          let transferHistory = await this.client.getAssetOperations({
+            operationsType: [operationsType],
+            operationsStatus: ["COMPLETED" /* COMPLETED */]
+          });
+          if (operationsType === "DEPOSIT" /* DEPOSIT */) {
+            const myTransferStatus = transferHistory.data.find(
+              (operation) => operation.transactionHash === orderId
+            );
+            if (!myTransferStatus) {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+              );
+              return false;
+            }
+            if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+              logger2.info(
+                `Deposit operation ${orderId} completed successfully`
+              );
+              return true;
+            } else {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Deposit operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+              );
+              return false;
+            }
+          } else {
+            const myTransferStatus = transferHistory.data.find(
+              (operation) => operation.id.toString() === orderId.toString()
+            );
+            if (!myTransferStatus) {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+              );
+              return false;
+            }
+            if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+              logger2.info(
+                `Withdrawal operation ${orderId} completed successfully`
+              );
+              return true;
+            } else {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Withdrawal operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+              );
+              return false;
+            }
           }
-          return true;
-        } else {
-          const myTransferStatus = transferHistory.data.find(
-            (operation) => operation.id.toString() === orderId.toString()
+        } catch (err2) {
+          logger2.error(
+            `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err2}`
           );
-          if (!myTransferStatus) {
-            return true;
+          if (attempt < maxAttempts) {
+            logger2.info(`Retrying after ${retryDelayMs}ms...`);
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            continue;
           }
-          return true;
+          logger2.error(
+            `Max retry attempts reached for getDepositOrWithdrawalStatus`
+          );
+          return false;
         }
-      } catch (err2) {
-        logger2.error(`error getting deposit or withdrawal status: ${err2}`);
-        return false;
       }
+      return false;
     }
   };
 
@@ -98741,7 +98810,6 @@ spurious results.`);
             if (!openLongPosition) {
               logger2.error(`error opening long position: ${openLongPosition}`);
             }
-            await new Promise((resolve) => setTimeout(resolve, 5e3));
             const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
             if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
               logger2.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
@@ -98752,7 +98820,7 @@ spurious results.`);
           if (withdrawalFromExtended) {
             const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
             logger2.info(`extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`);
-            await new Promise((resolve) => setTimeout(resolve, 1e4));
+            await new Promise((resolve) => setTimeout(resolve, 2e3));
             const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
             if (calls.length > 0) {
               return {

package/dist/index.browser.mjs

@@ -30288,32 +30288,101 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     }
   }
   async getDepositOrWithdrawalStatus(orderId, operationsType) {
-    try {
-      let transferHistory = await this.client.getAssetOperations({
-        operationsType: [operationsType],
-        operationsStatus: ["COMPLETED" /* COMPLETED */]
-      });
-      if (operationsType === "DEPOSIT" /* DEPOSIT */) {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.transactionHash === orderId
-        );
-        if (!myTransferStatus) {
-          return true;
+    const maxAttempts = 5;
+    const retryDelayMs = 3e4;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        let transferHistory = await this.client.getAssetOperations({
+          operationsType: [operationsType],
+          operationsStatus: ["COMPLETED" /* COMPLETED */]
+        });
+        if (operationsType === "DEPOSIT" /* DEPOSIT */) {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.transactionHash === orderId
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Deposit operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
+        } else {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.id.toString() === orderId.toString()
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Withdrawal operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
         }
-        return true;
-      } else {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.id.toString() === orderId.toString()
+      } catch (err) {
+        logger.error(
+          `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err}`
         );
-        if (!myTransferStatus) {
-          return true;
+        if (attempt < maxAttempts) {
+          logger.info(`Retrying after ${retryDelayMs}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+          continue;
         }
-        return true;
+        logger.error(
+          `Max retry attempts reached for getDepositOrWithdrawalStatus`
+        );
+        return false;
       }
-    } catch (err) {
-      logger.error(`error getting deposit or withdrawal status: ${err}`);
-      return false;
     }
+    return false;
   }
 };
 
@@ -34719,7 +34788,6 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           if (!openLongPosition) {
             logger.error(`error opening long position: ${openLongPosition}`);
           }
-          await new Promise((resolve) => setTimeout(resolve, 5e3));
           const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
           if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
             logger.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
@@ -34730,7 +34798,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         if (withdrawalFromExtended) {
           const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
           logger.info(`extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`);
-          await new Promise((resolve) => setTimeout(resolve, 1e4));
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
           const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
           if (calls.length > 0) {
             return {

package/dist/index.d.ts

@@ -1535,7 +1535,8 @@ declare class ExtendedAdapter extends BaseAdapter<DepositParams, WithdrawParams>
     createExtendedPositon(client: ExtendedWrapper, marketName: string, amount: string, price: string, side: OrderSide): Promise<{
         position_id: string;
     } | null>;
-    getDepositOrWithdrawalStatus(orderId: number | string, operationsType: AssetOperationType): Promise<boolean>;
+    getDepositOrWithdrawalStatus(orderId: number | string, // for deposits, send txn hash as string
+    operationsType: AssetOperationType): Promise<boolean>;
 }
 
 declare const SIMPLE_SANITIZER: ContractAddr;

package/dist/index.js

@@ -30441,32 +30441,101 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     }
   }
   async getDepositOrWithdrawalStatus(orderId, operationsType) {
-    try {
-      let transferHistory = await this.client.getAssetOperations({
-        operationsType: [operationsType],
-        operationsStatus: ["COMPLETED" /* COMPLETED */]
-      });
-      if (operationsType === "DEPOSIT" /* DEPOSIT */) {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.transactionHash === orderId
-        );
-        if (!myTransferStatus) {
-          return true;
+    const maxAttempts = 5;
+    const retryDelayMs = 3e4;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        let transferHistory = await this.client.getAssetOperations({
+          operationsType: [operationsType],
+          operationsStatus: ["COMPLETED" /* COMPLETED */]
+        });
+        if (operationsType === "DEPOSIT" /* DEPOSIT */) {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.transactionHash === orderId
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Deposit operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
+        } else {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.id.toString() === orderId.toString()
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Withdrawal operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
         }
-        return true;
-      } else {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.id.toString() === orderId.toString()
+      } catch (err) {
+        logger.error(
+          `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err}`
         );
-        if (!myTransferStatus) {
-          return true;
+        if (attempt < maxAttempts) {
+          logger.info(`Retrying after ${retryDelayMs}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+          continue;
         }
-        return true;
+        logger.error(
+          `Max retry attempts reached for getDepositOrWithdrawalStatus`
+        );
+        return false;
       }
-    } catch (err) {
-      logger.error(`error getting deposit or withdrawal status: ${err}`);
-      return false;
     }
+    return false;
   }
 };
 
@@ -34872,7 +34941,6 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           if (!openLongPosition) {
             logger.error(`error opening long position: ${openLongPosition}`);
           }
-          await new Promise((resolve) => setTimeout(resolve, 5e3));
           const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
           if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
             logger.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
@@ -34883,7 +34951,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         if (withdrawalFromExtended) {
           const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
           logger.info(`extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`);
-          await new Promise((resolve) => setTimeout(resolve, 1e4));
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
           const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
           if (calls.length > 0) {
             return {

package/dist/index.mjs

@@ -30299,32 +30299,101 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     }
   }
   async getDepositOrWithdrawalStatus(orderId, operationsType) {
-    try {
-      let transferHistory = await this.client.getAssetOperations({
-        operationsType: [operationsType],
-        operationsStatus: ["COMPLETED" /* COMPLETED */]
-      });
-      if (operationsType === "DEPOSIT" /* DEPOSIT */) {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.transactionHash === orderId
-        );
-        if (!myTransferStatus) {
-          return true;
+    const maxAttempts = 5;
+    const retryDelayMs = 3e4;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        let transferHistory = await this.client.getAssetOperations({
+          operationsType: [operationsType],
+          operationsStatus: ["COMPLETED" /* COMPLETED */]
+        });
+        if (operationsType === "DEPOSIT" /* DEPOSIT */) {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.transactionHash === orderId
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Deposit operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
+        } else {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.id.toString() === orderId.toString()
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Withdrawal operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
         }
-        return true;
-      } else {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.id.toString() === orderId.toString()
+      } catch (err) {
+        logger.error(
+          `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err}`
         );
-        if (!myTransferStatus) {
-          return true;
+        if (attempt < maxAttempts) {
+          logger.info(`Retrying after ${retryDelayMs}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+          continue;
         }
-        return true;
+        logger.error(
+          `Max retry attempts reached for getDepositOrWithdrawalStatus`
+        );
+        return false;
       }
-    } catch (err) {
-      logger.error(`error getting deposit or withdrawal status: ${err}`);
-      return false;
     }
+    return false;
   }
 };
 
@@ -34730,7 +34799,6 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           if (!openLongPosition) {
             logger.error(`error opening long position: ${openLongPosition}`);
           }
-          await new Promise((resolve) => setTimeout(resolve, 5e3));
           const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
           if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
             logger.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
@@ -34741,7 +34809,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         if (withdrawalFromExtended) {
           const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
           logger.info(`extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`);
-          await new Promise((resolve) => setTimeout(resolve, 1e4));
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
           const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
           if (calls.length > 0) {
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "2.0.0-dev.8",
+  "version": "2.0.0-dev.9",
   "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/strategies/universal-adapters/extended-adapter.ts

@@ -866,34 +866,107 @@ export class ExtendedAdapter extends BaseAdapter<
   }
 
   async getDepositOrWithdrawalStatus(
-    orderId: number | string,
+    orderId: number | string, // for deposits, send txn hash as string
     operationsType: AssetOperationType
   ): Promise<boolean> {
-    try {
-      let transferHistory = await this.client.getAssetOperations({
-        operationsType: [operationsType],
-        operationsStatus: [AssetOperationStatus.COMPLETED],
-      });
-      if (operationsType === AssetOperationType.DEPOSIT) {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.transactionHash === orderId
-        );
-        if (!myTransferStatus) {
-          return true;
+    const maxAttempts = 5;
+    const retryDelayMs = 30000; // 30 seconds
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        let transferHistory = await this.client.getAssetOperations({
+          operationsType: [operationsType],
+          operationsStatus: [AssetOperationStatus.COMPLETED],
+        });
+        if (operationsType === AssetOperationType.DEPOSIT) {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.transactionHash === orderId
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          // Check if status is COMPLETED
+          if (myTransferStatus.status === AssetOperationStatus.COMPLETED) {
+            logger.info(
+              `Deposit operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
+        } else {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.id.toString() === orderId.toString()
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          // Check if status is COMPLETED
+          if (myTransferStatus.status === AssetOperationStatus.COMPLETED) {
+            logger.info(
+              `Withdrawal operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
         }
-        return true;
-      } else {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.id.toString() === orderId.toString()
+      } catch (err) {
+        logger.error(
+          `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err}`
         );
-        if (!myTransferStatus) {
-          return true;
+        if (attempt < maxAttempts) {
+          logger.info(`Retrying after ${retryDelayMs}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+          continue;
         }
-        return true;
+        logger.error(
+          `Max retry attempts reached for getDepositOrWithdrawalStatus`
+        );
+        return false;
       }
-    } catch (err) {
-      logger.error(`error getting deposit or withdrawal status: ${err}`);
-      return false;
     }
+
+    return false;
   }
 }

package/src/strategies/vesu-extended-strategy/vesu-extended-strategy.tsx

@@ -737,7 +737,6 @@ export class VesuExtendedMultiplierStrategy<
           if (!openLongPosition) {
             logger.error(`error opening long position: ${openLongPosition}`);
           }
-          await new Promise(resolve => setTimeout(resolve, 5000));
           const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
           if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
             logger.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
@@ -752,7 +751,7 @@ export class VesuExtendedMultiplierStrategy<
           */
           const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
           logger.info(`extendedHoldings after withdrawal ${extendedHoldings?.availableForWithdrawal}`);
-          await new Promise(resolve => setTimeout(resolve, 10000));
+          await new Promise(resolve => setTimeout(resolve, 2000));
           const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
           if (calls.length > 0) {
             return {