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

package/dist/index.browser.global.js

@@ -91443,11 +91443,6 @@ spurious results.`);
       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(config3, this.config.poolId);
       const output = await contract.call(isV2 ? "position" : "position_unsafe", [
         ...isV2 ? [] : [this.config.poolId.address],
@@ -91473,7 +91468,6 @@ spurious results.`);
         usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
         remarks: "Debt"
       }];
-      this.setCache(CACHE_KEY, value, 6e4);
       return value.map((v) => ({ ...v, protocol: Protocols.VESU }));
     }
     async getCollateralization(config3, blockNumber = "latest") {
@@ -93981,26 +93975,38 @@ spurious results.`);
       try {
         if (!this.client) {
           logger2.error("Client not initialized");
-          return false;
+          return {
+            status: false,
+            receivedTxnHash: false
+          };
         }
         if (amount.lessThanOrEqualTo(0)) {
           logger2.error(
             `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
           );
-          return false;
+          return {
+            status: false,
+            receivedTxnHash: false
+          };
         }
         if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
           logger2.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) {
           logger2.error(
             "Cannot get holdings - unable to validate withdrawal amount"
           );
-          return false;
+          return {
+            status: false,
+            receivedTxnHash: false
+          };
         }
         const availableForWithdrawal = parseFloat(
           holdings.availableForWithdrawal
@@ -94009,14 +94015,20 @@ spurious results.`);
           logger2.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) {
           logger2.error(
             `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
           );
-          return false;
+          return {
+            status: false,
+            receivedTxnHash: false
+          };
         }
         logger2.info(
           `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`
@@ -94029,15 +94041,24 @@ spurious results.`);
             withdrawalRequest.data,
             "WITHDRAWAL" /* WITHDRAWAL */
           );
-          return withdrawalStatus;
+          return {
+            status: true,
+            receivedTxnHash: withdrawalStatus
+          };
         }
         logger2.error(
           `Withdrawal request failed with status: ${withdrawalRequest.status}`
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       } catch (error2) {
         logger2.error(`Error creating Withdraw Call: ${error2}`);
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
     }
     async getHealthFactor() {
@@ -98385,10 +98406,16 @@ spurious results.`);
           proofGroups,
           await proofsInfo.callConstructor({ amount })
         );
-        return [approveCall, transferCall, call];
+        return {
+          calls: [approveCall, transferCall, call],
+          status: true
+        };
       } catch (err2) {
         logger2.error(`error moving assets to vault allocator: ${err2}`);
-        return [];
+        return {
+          calls: [],
+          status: false
+        };
       }
     }
     async shouldInvest() {
@@ -98637,9 +98664,10 @@ spurious results.`);
         const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
         logger2.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,
@@ -98649,17 +98677,25 @@ spurious results.`);
               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 (err2) {
             logger2.error(`Failed moving assets to vault: ${err2}`);
+            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,
@@ -98668,18 +98704,26 @@ spurious results.`);
               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 (err2) {
-            logger2.error(`Failed moving assets to vault: ${err2}`);
+            logger2.error(`Failed moving assets to extended via vault allocator: ${err2}`);
+            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,
@@ -98689,18 +98733,22 @@ spurious results.`);
                 vesuAdapter
               );
               if (extendedStatus) {
-                calls.push(...extendedCalls);
+                transactionResults.push({
+                  status: extendedStatus,
+                  calls: extendedCalls,
+                  transactionMetadata: extendedTransactionMetadata
+                });
               } else {
                 logger2.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 (err2) {
               logger2.error(`Failed moving assets to extended: ${err2}`);
-              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,
@@ -98710,14 +98758,21 @@ spurious results.`);
                 vesuAdapter
               );
               if (extendedStatus) {
-                calls.push(...extendedCalls);
+                transactionResults.push({
+                  status: extendedStatus,
+                  calls: extendedCalls,
+                  transactionMetadata: {
+                    ...extendedTransactionMetadata,
+                    transactionType: "DEPOSIT"
+                  }
+                });
               } else {
                 logger2.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 (err2) {
               logger2.error(`Failed moving assets from extended to vault: ${err2}`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE")];
             }
           }
         }
@@ -98728,7 +98783,7 @@ spurious results.`);
             );
           } 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,
@@ -98739,31 +98794,54 @@ spurious results.`);
               );
               if (!vesuStatus) {
                 logger2.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 (err2) {
               logger2.error(`Failed moving assets to vault: ${err2}`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE")];
             }
           }
         }
-        return calls;
+        return transactionResults;
       } catch (err2) {
         logger2.error(`Failed moving assets to vesu: ${err2}`);
-        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)) {
           logger2.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) {
@@ -98771,10 +98849,7 @@ spurious results.`);
             logger2.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) {
@@ -98782,19 +98857,13 @@ spurious results.`);
             logger2.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) {
           logger2.error(`avnu adapter not found: ${avnuAdapter}`);
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
         logger2.info(`moveAssets params, ${JSON.stringify(params)}`);
         const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
@@ -98813,19 +98882,13 @@ spurious results.`);
             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) {
             logger2.error(`error getting extended holdings: ${extendedHoldings}`);
-            return {
-              calls: [],
-              status: false
-            };
+            return this.createTransactionResult([], false, params, "NONE");
           }
           const extendedHoldingAmount = new Web3Number(
             extendedHoldings.availableForWithdrawal,
@@ -98852,36 +98915,36 @@ spurious results.`);
             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()}`);
-              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);
+          logger2.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
+          if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
             const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
             logger2.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) {
+            logger2.error("withdrawal from extended successful, but funds didn't get transferred to the wallet");
+            return this.createTransactionResult([], true, params, "WITHDRAWAL");
           } else {
             logger2.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) {
             logger2.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),
@@ -98902,18 +98965,12 @@ spurious results.`);
             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) {
             logger2.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(),
@@ -98944,127 +99001,21 @@ spurious results.`);
             await proofsInfoDeposit.callConstructor({ amount: params.amount })
           );
           calls.push(callDeposit);
-          return {
-            calls,
-            status: true
-          };
+          return this.createTransactionResult(calls, true, params, "DEPOSIT");
         }
-        return {
-          calls: [],
-          status: false
-        };
+        logger2.error(`Unsupported assets movement: ${params.from} to ${params.to}`);
+        return this.createTransactionResult([], false, params, "NONE");
       } catch (err2) {
         logger2.error(`error moving assets: ${err2}`);
-        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) {
-          logger2.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) {
-          logger2.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) {
-          logger2.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) {
-          logger2.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
-        );
-        logger2.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)) {
-          logger2.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 (err2) {
         logger2.error(`error handling deposit: ${err2}`);
-        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) {
@@ -99109,12 +99060,8 @@ spurious results.`);
           const withdrawCall2 = await this.getBringLiquidityCall({
             amount: usdcBalanceVaultAllocator.amount
           });
-          logger2.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();
@@ -99123,11 +99070,9 @@ spurious results.`);
           logger2.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
@@ -99136,10 +99081,7 @@ spurious results.`);
         if (!extendedPositon) {
           status = false;
           logger2.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,
@@ -99152,14 +99094,11 @@ spurious results.`);
           logger2.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,
@@ -99169,10 +99108,14 @@ spurious results.`);
             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,
@@ -99183,30 +99126,35 @@ spurious results.`);
           );
           status = extendedStatus;
           if (status) {
-            calls.push(...extendedCalls);
+            transactionResults.push({
+              status: extendedStatus,
+              calls: extendedCalls,
+              transactionMetadata: extendedTransactionMetadata
+            });
           } else {
             logger2.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
         });
         logger2.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 (err2) {
         logger2.error(`error handling withdrawal: ${err2}`);
-        return {
-          calls: [],
-          status: false
-        };
+        return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
       }
     }
     async getAUM() {
@@ -99253,6 +99201,36 @@ spurious results.`);
         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 (err2) {
+        logger2.error(`error processing transaction data from SDK: ${err2}`);
+        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 (err2) {
+        logger2.error(`error processing transaction data from SDK: ${err2}`);
+        return null;
+      }
+    }
   };
   function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
     vaultSettings.leafAdapters = [];