@strkfarm/sdk 2.0.0-dev.14 → 2.0.0-dev.16

package/dist/index.browser.mjs

@@ -27407,11 +27407,6 @@ var VesuAdapter = class _VesuAdapter extends CacheClass {
     if (!this.pricer) {
       throw new Error("Pricer is not initialized");
     }
-    const CACHE_KEY = `positions_${blockNumber}_${this.config.poolId.shortString()}_${this.config.collateral.symbol}_${this.config.debt.symbol}`;
-    const cacheData = this.getCache(CACHE_KEY);
-    if (cacheData) {
-      return cacheData;
-    }
     const { contract, isV2 } = this.getVesuSingletonContract(config, this.config.poolId);
     const output = await contract.call(isV2 ? "position" : "position_unsafe", [
       ...isV2 ? [] : [this.config.poolId.address],
@@ -27437,7 +27432,6 @@ var VesuAdapter = class _VesuAdapter extends CacheClass {
       usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
       remarks: "Debt"
     }];
-    this.setCache(CACHE_KEY, value, 6e4);
     return value.map((v) => ({ ...v, protocol: Protocols.VESU }));
   }
   async getCollateralization(config, blockNumber = "latest") {
@@ -29951,26 +29945,38 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     try {
       if (!this.client) {
         logger.error("Client not initialized");
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       if (amount.lessThanOrEqualTo(0)) {
         logger.error(
           `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
         logger.warn(
           `Withdrawal amount ${amount.toNumber()} is below minimum Extended movement amount ${this.minimumExtendedMovementAmount}. Skipping withdrawal.`
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       const holdings = await this.getExtendedDepositAmount();
       if (!holdings) {
         logger.error(
           "Cannot get holdings - unable to validate withdrawal amount"
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       const availableForWithdrawal = parseFloat(
         holdings.availableForWithdrawal
@@ -29979,14 +29985,20 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         logger.error(
           `Invalid availableForWithdrawal: ${holdings.availableForWithdrawal}. Expected a finite, non-negative number.`
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       const withdrawalAmount = amount.toNumber();
       if (withdrawalAmount > availableForWithdrawal) {
         logger.error(
           `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       logger.info(
         `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`
@@ -29999,15 +30011,24 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
           withdrawalRequest.data,
           "WITHDRAWAL" /* WITHDRAWAL */
         );
-        return withdrawalStatus;
+        return {
+          status: true,
+          receivedTxnHash: withdrawalStatus
+        };
       }
       logger.error(
         `Withdrawal request failed with status: ${withdrawalRequest.status}`
       );
-      return false;
+      return {
+        status: false,
+        receivedTxnHash: false
+      };
     } catch (error) {
       logger.error(`Error creating Withdraw Call: ${error}`);
-      return false;
+      return {
+        status: false,
+        receivedTxnHash: false
+      };
     }
   }
   async getHealthFactor() {
@@ -34360,10 +34381,16 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         proofGroups,
         await proofsInfo.callConstructor({ amount })
       );
-      return [approveCall, transferCall, call];
+      return {
+        calls: [approveCall, transferCall, call],
+        status: true
+      };
     } catch (err) {
       logger.error(`error moving assets to vault allocator: ${err}`);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     }
   }
   async shouldInvest() {
@@ -34612,9 +34639,10 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
       logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`);
       let calls = [];
+      let transactionResults = [];
       if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
         try {
-          const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+          const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
             {
               to: Protocols.VAULT.name,
               from: Protocols.EXTENDED.name,
@@ -34624,17 +34652,25 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             vesuAdapter
           );
           if (extendedStatus) {
-            calls.push(...extendedCalls);
+            transactionResults.push({
+              status: extendedStatus,
+              calls: extendedCalls,
+              transactionMetadata: {
+                ...extendedTransactionMetadata,
+                transactionType: "DEPOSIT"
+              }
+            });
           } else {
-            return [];
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE")];
           }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
+          return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE")];
         }
       }
       if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
         try {
-          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+          const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
             {
               to: Protocols.EXTENDED.name,
               from: Protocols.VESU.name,
@@ -34643,18 +34679,26 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             extendedAdapter,
             vesuAdapter
           );
-          calls.push(...vesuCalls);
           if (!vesuStatus) {
-            return [];
-          }
+            return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE")];
+          }
+          transactionResults.push({
+            status: vesuStatus,
+            calls: vesuCalls,
+            transactionMetadata: {
+              ...vesuTransactionMetadata,
+              transactionType: "DEPOSIT"
+            }
+          });
         } catch (err) {
-          logger.error(`Failed moving assets to vault: ${err}`);
+          logger.error(`Failed moving assets to extended via vault allocator: ${err}`);
+          return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE")];
         }
       }
       if (extendedAmountDifferenceAbs.greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
         if (extendedAmountDifference.greaterThan(0)) {
           try {
-            const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
               {
                 to: Protocols.EXTENDED.name,
                 from: Protocols.VAULT.name,
@@ -34664,18 +34708,22 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
               vesuAdapter
             );
             if (extendedStatus) {
-              calls.push(...extendedCalls);
+              transactionResults.push({
+                status: extendedStatus,
+                calls: extendedCalls,
+                transactionMetadata: extendedTransactionMetadata
+              });
             } else {
               logger.error(`Failed to move assets to extended - operation returned false status`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE")];
             }
           } catch (err) {
             logger.error(`Failed moving assets to extended: ${err}`);
-            return [];
+            return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE")];
           }
         } else if (extendedAmountDifference.lessThan(0)) {
           try {
-            const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
@@ -34685,14 +34733,21 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
               vesuAdapter
             );
             if (extendedStatus) {
-              calls.push(...extendedCalls);
+              transactionResults.push({
+                status: extendedStatus,
+                calls: extendedCalls,
+                transactionMetadata: {
+                  ...extendedTransactionMetadata,
+                  transactionType: "DEPOSIT"
+                }
+              });
             } else {
               logger.error(`Failed to withdraw from extended - operation returned false status`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE")];
             }
           } catch (err) {
             logger.error(`Failed moving assets from extended to vault: ${err}`);
-            return [];
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE")];
           }
         }
       }
@@ -34703,7 +34758,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           );
         } else {
           try {
-            const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+            const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
@@ -34714,31 +34769,54 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             );
             if (!vesuStatus) {
               logger.error(`Failed to move assets to vesu - operation returned false status`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE")];
             }
-            calls.push(...vesuCalls);
+            transactionResults.push({
+              status: vesuStatus,
+              calls: vesuCalls,
+              transactionMetadata: {
+                ...vesuTransactionMetadata,
+                transactionType: "DEPOSIT"
+              }
+            });
           } catch (err) {
             logger.error(`Failed moving assets to vault: ${err}`);
-            return [];
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE")];
           }
         }
       }
-      return calls;
+      return transactionResults;
     } catch (err) {
       logger.error(`Failed moving assets to vesu: ${err}`);
-      return [];
+      return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: new Web3Number(0, USDC_TOKEN_DECIMALS) }, "NONE")];
     }
   }
+  /**
+   * Helper method to create transaction result with metadata
+   */
+  createTransactionResult(calls, status, params, transactionType) {
+    if (status) {
+      return {
+        calls,
+        status,
+        transactionMetadata: {
+          protocolFrom: params.from,
+          protocolTo: params.to,
+          transactionType,
+          usdAmount: params.amount.abs().toFixed(),
+          status: "PENDING"
+        }
+      };
+    }
+    return { calls: [], status: false, transactionMetadata: { protocolFrom: "", protocolTo: "", transactionType: "DEPOSIT", usdAmount: "0", status: "FAILED" } };
+  }
   async moveAssets(params, extendedAdapter, vesuAdapter) {
     try {
       if (params.amount.lessThanOrEqualTo(0)) {
         logger.error(
           `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
         );
-        return {
-          calls: [],
-          status: false
-        };
+        return this.createTransactionResult([], false, params, "NONE");
       }
       const amountAbs = params.amount.abs();
       if (params.from === Protocols.EXTENDED.name || params.to === Protocols.EXTENDED.name) {
@@ -34746,10 +34824,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           logger.warn(
             `Amount ${amountAbs.toNumber()} is below minimum Extended movement amount ${extendedAdapter.minimumExtendedMovementAmount}. Skipping operation.`
           );
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
       }
       if (params.from === Protocols.VESU.name || params.to === Protocols.VESU.name) {
@@ -34757,19 +34832,13 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           logger.warn(
             `Amount ${amountAbs.toNumber()} is below minimum Vesu movement amount ${vesuAdapter.minimumVesuMovementAmount}. Skipping operation.`
           );
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
       }
       const avnuAdapter = await this.getAvnuAdapter();
       if (!avnuAdapter) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return {
-          calls: [],
-          status: false
-        };
+        return this.createTransactionResult([], false, params, "NONE");
       }
       logger.info(`moveAssets params, ${JSON.stringify(params)}`);
       const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
@@ -34788,19 +34857,13 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfo.callConstructor({ amount: params.amount })
         );
         calls.push(call);
-        return {
-          calls: [call],
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "DEPOSIT");
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.EXTENDED.name) {
         const extendedLeverage = calculateExtendedLevergae();
         const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
         if (!extendedHoldings) {
           logger.error(`error getting extended holdings: ${extendedHoldings}`);
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
         const extendedHoldingAmount = new Web3Number(
           extendedHoldings.availableForWithdrawal,
@@ -34827,36 +34890,36 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           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()}`);
-            return { calls: [], status: false };
+            return this.createTransactionResult([], false, params, "NONE");
           }
         }
-        const withdrawalFromExtended = await extendedAdapter.withdrawFromExtended(params.amount);
-        if (withdrawalFromExtended) {
+        const {
+          status: withdrawalFromExtendedStatus,
+          receivedTxnHash: withdrawalFromExtendedTxnHash
+        } = await extendedAdapter.withdrawFromExtended(params.amount);
+        logger.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
+        if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
           const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
           logger.info(`extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`);
           await new Promise((resolve) => setTimeout(resolve, 5e3));
-          const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
-          if (calls.length > 0) {
-            return {
-              calls,
-              status: true
-            };
+          const { calls, status } = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
+          if (calls.length > 0 && status) {
+            return this.createTransactionResult(calls, true, params, "WITHDRAWAL");
+          } else {
+            return this.createTransactionResult([], true, params, "WITHDRAWAL");
           }
+        } else if (withdrawalFromExtendedStatus && !withdrawalFromExtendedTxnHash) {
+          logger.error("withdrawal from extended successful, but funds didn't get transferred to the wallet");
+          return this.createTransactionResult([], true, params, "WITHDRAWAL");
         } else {
           logger.error("withdrawal from extended failed");
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.VESU.name) {
         const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
         if (!isPriceDifferenceBetweenAvnuAndExtended) {
           logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toFixed(WBTC_TOKEN_DECIMALS),
@@ -34877,18 +34940,12 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(swapCall);
-        return {
-          calls,
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "WITHDRAWAL");
       } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
         const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
         if (!isPriceDifferenceBetweenAvnuAndExtended) {
           logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
@@ -34919,127 +34976,21 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfoDeposit.callConstructor({ amount: params.amount })
         );
         calls.push(callDeposit);
-        return {
-          calls,
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "DEPOSIT");
       }
-      return {
-        calls: [],
-        status: false
-      };
+      logger.error(`Unsupported assets movement: ${params.from} to ${params.to}`);
+      return this.createTransactionResult([], false, params, "NONE");
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return {
-        calls: [],
-        status: false
-      };
+      return this.createTransactionResult([], false, params, "NONE");
     }
   }
   async handleDeposit() {
     try {
-      const vesuAdapter = await this.getVesuAdapter();
-      const extendedAdapter = await this.getExtendedAdapter();
-      const avnuAdapter = await this.getAvnuAdapter();
-      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client || !avnuAdapter) {
-        logger.error(
-          "vesu or extended adapter not found",
-          vesuAdapter,
-          extendedAdapter
-        );
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const extendedLeverage = calculateExtendedLevergae();
-      const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "open" /* OPEN */);
-      if (!isPriceDifferenceBetweenAvnuAndExtended) {
-        logger.error("price difference between avnu and extended doesn't fit the range");
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const position = await extendedAdapter.getAllOpenPositions();
-      if (!position) {
-        logger.error("error getting extended position", position);
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const extendedPositionValue = position.length > 0 ? parseFloat(position[0].value) : 0;
-      const BUFFER_AMOUNT_IN_AVAILABLE_FOR_TRADE = BUFFER_USDC_IN_WITHDRAWAL;
-      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-      if (!extendedHoldings) {
-        logger.error(`error getting extended holdings: ${extendedHoldings}`);
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const extendedHoldingAmount = new Web3Number(
-        extendedHoldings.availableForWithdrawal,
-        USDC_TOKEN_DECIMALS
-      );
-      const {
-        collateralTokenAmount
-      } = await vesuAdapter.vesuAdapter.getAssetPrices();
-      const { collateralPrice } = await this.getAssetPrices();
-      const { vesuAmountInBTC, extendedAmountInBTC } = calculateVesUPositionSizeGivenExtended(
-        extendedPositionValue,
-        extendedHoldingAmount.minus(BUFFER_AMOUNT_IN_AVAILABLE_FOR_TRADE),
-        collateralTokenAmount,
-        collateralPrice.price
-      );
-      logger.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTC}`);
-      let calls = [];
-      if (vesuAmountInBTC.greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
-        const proofsInfo = vesuAdapter.getProofs(true, this.getMerkleTree());
-        const proofGroups = proofsInfo.proofs;
-        const call = this.getManageCall(
-          proofGroups,
-          await proofsInfo.callConstructor({
-            amount: vesuAmountInBTC
-          })
-        );
-        const { amount: wbtcAmountInVaultAllocator } = await this.getUnusedBalanceWBTC();
-        if (wbtcAmountInVaultAllocator.lessThan(vesuAmountInBTC)) {
-          const swapProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
-          const swapProofGroups = swapProofsInfo.proofs;
-          const swapCall = this.getManageCall(
-            swapProofGroups,
-            await swapProofsInfo.callConstructor({
-              amount: vesuAmountInBTC
-            })
-          );
-          calls.push(swapCall);
-        }
-        calls.push(call);
-      }
-      const shortPosition = extendedAmountInBTC.multipliedBy(3).abs().greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
-        extendedLeverage.toString(),
-        extendedAmountInBTC.toNumber(),
-        "SELL" /* SELL */
-      ) : null;
-      if (!shortPosition && extendedAmountInBTC.multipliedBy(3).abs().greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
-        logger.error(`error creating short position thus no position to be opened on vesu: ${shortPosition}`);
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      return {
-        extendedAmountInBTC,
-        calls
-      };
+      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE");
     } catch (err) {
       logger.error(`error handling deposit: ${err}`);
-      return {
-        extendedAmountInBTC: new Web3Number(0, 0),
-        calls: []
-      };
+      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE");
     }
   }
   async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, positionType) {
@@ -35084,12 +35035,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         const withdrawCall2 = await this.getBringLiquidityCall({
           amount: usdcBalanceVaultAllocator.amount
         });
-        logger.info("withdraw call", withdrawCall2);
         calls.push(withdrawCall2);
-        return {
-          calls,
-          status: true
-        };
+        return [this.createTransactionResult(calls, true, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "WITHDRAWAL")];
       }
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
@@ -35098,11 +35045,9 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return {
-          calls,
-          status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
       }
+      let transactionResults = [];
       const { collateralTokenAmount } = await vesuAdapter.vesuAdapter.getAssetPrices();
       const {
         collateralPrice
@@ -35111,10 +35056,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       if (!extendedPositon) {
         status = false;
         logger.error("error getting extended position", extendedPositon);
-        return {
-          calls,
-          status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
       }
       const amountDistributionForWithdrawal = await calculateAmountDistributionForWithdrawal(
         usdcBalanceDifference,
@@ -35127,14 +35069,11 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.error(
           `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
         );
-        return {
-          calls,
-          status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
       }
       const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
       if (status && vesu_amount.greaterThan(0)) {
-        const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+        const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
           {
             amount: vesu_amount,
             from: Protocols.VESU.name,
@@ -35144,10 +35083,14 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           vesuAdapter
         );
         status = vesuStatus;
-        calls.push(...vesuCalls);
+        transactionResults.push({
+          status: vesuStatus,
+          calls: vesuCalls,
+          transactionMetadata: vesuTransactionMetadata
+        });
       }
       if (status && extended_amount.greaterThan(0)) {
-        const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+        const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
           {
             amount: extended_amount,
             from: Protocols.EXTENDED.name,
@@ -35158,30 +35101,35 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         );
         status = extendedStatus;
         if (status) {
-          calls.push(...extendedCalls);
+          transactionResults.push({
+            status: extendedStatus,
+            calls: extendedCalls,
+            transactionMetadata: extendedTransactionMetadata
+          });
         } else {
           logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
-          return {
-            calls: [],
-            status
-          };
+          return [this.createTransactionResult([], status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
         }
       }
       const withdrawCall = await this.getBringLiquidityCall({
         amount
       });
       logger.info("withdraw call", withdrawCall);
-      calls.push(withdrawCall);
-      return {
-        calls,
-        status
-      };
+      transactionResults.push({
+        status,
+        calls: [withdrawCall],
+        transactionMetadata: {
+          protocolFrom: Protocols.VAULT.name,
+          protocolTo: Protocols.NONE.name,
+          transactionType: "WITHDRAWAL",
+          usdAmount: amount.toFixed(),
+          status: "PENDING"
+        }
+      });
+      return transactionResults;
     } catch (err) {
       logger.error(`error handling withdrawal: ${err}`);
-      return {
-        calls: [],
-        status: false
-      };
+      return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
     }
   }
   async getAUM() {
@@ -35228,6 +35176,36 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       splits: [realAUM, estimatedAUMDelta]
     };
   }
+  async processTransactionDataFromSDK(txnData) {
+    try {
+      const txnsToBeExecuted = txnData.filter((txn) => {
+        return txn.transactionMetadata.transactionType !== "NONE" && txn.transactionMetadata.protocolFrom !== "" && txn.transactionMetadata.protocolTo !== "";
+      });
+      const callsToBeExecutedFinal = txnsToBeExecuted.flatMap((txn) => txn.calls);
+      const txnMetadata = txnsToBeExecuted.map((txn) => txn.transactionMetadata);
+      return { callsToBeExecutedFinal, txnMetadata };
+    } catch (err) {
+      logger.error(`error processing transaction data from SDK: ${err}`);
+      return null;
+    }
+  }
+  async processTransactionMetadata(txnMetadata, extendedIntentFulfilled) {
+    try {
+      const txnMetadataNew = txnMetadata.map((txn) => {
+        const isExtendedProtocol = txn.protocolFrom === Protocols.EXTENDED.name || txn.protocolTo === Protocols.EXTENDED.name;
+        if (isExtendedProtocol) {
+          txn.status = extendedIntentFulfilled ? "COMPLETED" : "PENDING";
+        } else {
+          txn.status = "COMPLETED";
+        }
+        return txn;
+      });
+      return txnMetadataNew;
+    } catch (err) {
+      logger.error(`error processing transaction data from SDK: ${err}`);
+      return null;
+    }
+  }
 };
 function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
   vaultSettings.leafAdapters = [];