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

package/dist/index.browser.global.js

@@ -28659,6 +28659,7 @@ ${r2}}` : "}", l2;
     BaseStrategy: () => BaseStrategy,
     CommonAdapter: () => CommonAdapter,
     ContractAddr: () => ContractAddr,
+    CycleType: () => CycleType,
     ERC20: () => ERC20,
     EXTENDED_CONTRACT: () => EXTENDED_CONTRACT,
     EXTENDED_SANITIZER: () => EXTENDED_SANITIZER,
@@ -92386,9 +92387,7 @@ spurious results.`);
   var MAX_LTV_BTC_USDC = 0.8428;
   var MAX_LIQUIDATION_RATIO = 0.86;
   var VAULT_ID_EXTENDED = process.env.VAULT_ID_EXTENDED ?? 220774;
-  var WALLET_ADDRESS = process.env.WALLET_ADDRESS ?? "0x07b84bb6E87588BdAde0bfe6173A615b3C220F9C3803456aE183C50EA1d15Ba1";
-  var TESTNET_WALLET_ADDRESS = process.env.TESTNET_WALLET_ADDRESS ?? "0x07b84bb6E87588BdAde0bfe6173A615b3C220F9C3803456aE183C50EA1d15Ba1";
-  var TEST_WALLET_2 = process.env.TEST_WALLET_2 ?? "0x004C1bdC61DAc7947F3C93d0163d660012E2aB0521567f7155fcf502848791A7";
+  var WALLET_ADDRESS = process.env.WALLET_ADDRESS ?? "0x007E24592287427aaE9d291770B17d582E8A45f3aE54228F998793Ec769B7D13";
   var STRK_API_TEST_RPC = process.env.STRK_API_TEST_RPC ?? "https://sepolia.starknet.a5a.ch";
   var STRK_API_RPC = process.env.STRK_API_RPC ?? "https://mainnet.starknet.a5a.ch";
   var MAX_RETRIES = Number(process.env.MAX_RETRIES ?? 3);
@@ -93704,7 +93703,7 @@ spurious results.`);
       const amount = holdings.equity;
       return Promise.resolve({
         amount: new Web3Number(amount, 0),
-        remarks: `${holdings.availableForWithdrawal} ${holdings.equity}`
+        remarks: `Extended Equity`
       });
     }
     async maxDeposit(amount) {
@@ -94556,7 +94555,7 @@ spurious results.`);
       return Promise.resolve({ apy: 0, type: "base" /* BASE */ });
     }
     async getPosition(supportedPosition) {
-      return Promise.resolve({ amount: new Web3Number(0, 0), remarks: "" });
+      return Promise.resolve({ amount: new Web3Number(0, 0), remarks: "Avnu Positions" });
     }
     async maxDeposit(amount) {
       return Promise.resolve({
@@ -98290,6 +98289,16 @@ spurious results.`);
     getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
   ];
 
+  // src/strategies/vesu-extended-strategy/types/transaction-metadata.ts
+  var CycleType = /* @__PURE__ */ ((CycleType2) => {
+    CycleType2["INVESTMENT"] = "INVESTMENT";
+    CycleType2["REBALANCE_PRICE_DROP"] = "REBALANCE_PRICE_DROP";
+    CycleType2["REBALANCE_PRICE_RISE"] = "REBALANCE_PRICE_RISE";
+    CycleType2["WITHDRAWAL"] = "WITHDRAWAL";
+    CycleType2["DELTA_NEUTRAL_ADJUSTMENT"] = "DELTA_NEUTRAL_ADJUSTMENT";
+    return CycleType2;
+  })(CycleType || {});
+
   // src/strategies/vesu-extended-strategy/vesu-extended-strategy.tsx
   var import_jsx_runtime5 = __toESM(require_jsx_runtime());
   var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy extends SVKStrategy {
@@ -98671,7 +98680,8 @@ spurious results.`);
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
-                amount: extendedAmount.abs()
+                amount: extendedAmount.abs(),
+                cycleType: "INVESTMENT" /* INVESTMENT */
               },
               extendedAdapter,
               vesuAdapter
@@ -98686,11 +98696,11 @@ spurious results.`);
                 }
               });
             } else {
-              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE")];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
             }
           } 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")];
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
           }
         }
         if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
@@ -98699,13 +98709,14 @@ spurious results.`);
               {
                 to: Protocols.EXTENDED.name,
                 from: Protocols.VESU.name,
-                amount: vesuAmount.abs()
+                amount: vesuAmount.abs(),
+                cycleType: "INVESTMENT" /* INVESTMENT */
               },
               extendedAdapter,
               vesuAdapter
             );
             if (!vesuStatus) {
-              return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE")];
+              return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
             }
             transactionResults.push({
               status: vesuStatus,
@@ -98717,7 +98728,7 @@ spurious results.`);
             });
           } catch (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")];
+            return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
           }
         }
         if (extendedAmountDifferenceAbs.greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
@@ -98727,7 +98738,8 @@ spurious results.`);
                 {
                   to: Protocols.EXTENDED.name,
                   from: Protocols.VAULT.name,
-                  amount: extendedAmountDifference
+                  amount: extendedAmountDifference,
+                  cycleType: "INVESTMENT" /* INVESTMENT */
                 },
                 extendedAdapter,
                 vesuAdapter
@@ -98740,11 +98752,11 @@ spurious results.`);
                 });
               } else {
                 logger2.error(`Failed to move assets to extended - operation returned false status`);
-                return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE")];
+                return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
               }
             } catch (err2) {
               logger2.error(`Failed moving assets to extended: ${err2}`);
-              return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE")];
+              return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
             }
           } else if (extendedAmountDifference.lessThan(0)) {
             try {
@@ -98752,7 +98764,8 @@ spurious results.`);
                 {
                   to: Protocols.VAULT.name,
                   from: Protocols.EXTENDED.name,
-                  amount: extendedAmountDifferenceAbs
+                  amount: extendedAmountDifferenceAbs,
+                  cycleType: "INVESTMENT" /* INVESTMENT */
                 },
                 extendedAdapter,
                 vesuAdapter
@@ -98768,11 +98781,11 @@ spurious results.`);
                 });
               } else {
                 logger2.error(`Failed to withdraw from extended - operation returned false status`);
-                return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE")];
+                return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", "INVESTMENT" /* INVESTMENT */)];
               }
             } catch (err2) {
               logger2.error(`Failed moving assets from extended to vault: ${err2}`);
-              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE")];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", "INVESTMENT" /* INVESTMENT */)];
             }
           }
         }
@@ -98787,14 +98800,15 @@ spurious results.`);
                 {
                   to: Protocols.VAULT.name,
                   from: Protocols.EXTENDED.name,
-                  amount: vesuAmountDifference
+                  amount: vesuAmountDifference,
+                  cycleType: "INVESTMENT" /* INVESTMENT */
                 },
                 extendedAdapter,
                 vesuAdapter
               );
               if (!vesuStatus) {
                 logger2.error(`Failed to move assets to vesu - operation returned false status`);
-                return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE")];
+                return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
               }
               transactionResults.push({
                 status: vesuStatus,
@@ -98806,20 +98820,20 @@ spurious results.`);
               });
             } catch (err2) {
               logger2.error(`Failed moving assets to vault: ${err2}`);
-              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE")];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
             }
           }
         }
         return transactionResults;
       } catch (err2) {
         logger2.error(`Failed moving assets to vesu: ${err2}`);
-        return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: new Web3Number(0, USDC_TOKEN_DECIMALS) }, "NONE")];
+        return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: new Web3Number(0, USDC_TOKEN_DECIMALS) }, "NONE", "INVESTMENT" /* INVESTMENT */)];
       }
     }
     /**
      * Helper method to create transaction result with metadata
      */
-    createTransactionResult(calls, status, params, transactionType) {
+    createTransactionResult(calls, status, params, transactionType, cycleType) {
       if (status) {
         return {
           calls,
@@ -98829,11 +98843,12 @@ spurious results.`);
             protocolTo: params.to,
             transactionType,
             usdAmount: params.amount.abs().toFixed(),
-            status: "PENDING"
+            status: "PENDING",
+            cycleType
           }
         };
       }
-      return { calls: [], status: false, transactionMetadata: { protocolFrom: "", protocolTo: "", transactionType: "DEPOSIT", usdAmount: "0", status: "FAILED" } };
+      return { calls: [], status: false, transactionMetadata: { protocolFrom: "", protocolTo: "", transactionType: "DEPOSIT", usdAmount: "0", status: "FAILED", cycleType } };
     }
     async moveAssets(params, extendedAdapter, vesuAdapter) {
       try {
@@ -98841,7 +98856,7 @@ spurious results.`);
           logger2.error(
             `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
           );
-          return this.createTransactionResult([], false, params, "NONE");
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
         }
         const amountAbs = params.amount.abs();
         if (params.from === Protocols.EXTENDED.name || params.to === Protocols.EXTENDED.name) {
@@ -98849,7 +98864,7 @@ spurious results.`);
             logger2.warn(
               `Amount ${amountAbs.toNumber()} is below minimum Extended movement amount ${extendedAdapter.minimumExtendedMovementAmount}. Skipping operation.`
             );
-            return this.createTransactionResult([], false, params, "NONE");
+            return this.createTransactionResult([], false, params, "NONE", params.cycleType);
           }
         }
         if (params.from === Protocols.VESU.name || params.to === Protocols.VESU.name) {
@@ -98857,13 +98872,13 @@ spurious results.`);
             logger2.warn(
               `Amount ${amountAbs.toNumber()} is below minimum Vesu movement amount ${vesuAdapter.minimumVesuMovementAmount}. Skipping operation.`
             );
-            return this.createTransactionResult([], false, params, "NONE");
+            return this.createTransactionResult([], false, params, "NONE", params.cycleType);
           }
         }
         const avnuAdapter = await this.getAvnuAdapter();
         if (!avnuAdapter) {
           logger2.error(`avnu adapter not found: ${avnuAdapter}`);
-          return this.createTransactionResult([], false, params, "NONE");
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
         }
         logger2.info(`moveAssets params, ${JSON.stringify(params)}`);
         const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
@@ -98882,13 +98897,13 @@ spurious results.`);
             await proofsInfo.callConstructor({ amount: params.amount })
           );
           calls.push(call);
-          return this.createTransactionResult(calls, true, params, "DEPOSIT");
+          return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
         } 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 this.createTransactionResult([], false, params, "NONE");
+            return this.createTransactionResult([], false, params, "NONE", params.cycleType);
           }
           const extendedHoldingAmount = new Web3Number(
             extendedHoldings.availableForWithdrawal,
@@ -98905,7 +98920,7 @@ spurious results.`);
               "BUY" /* BUY */
             ) : await extendedAdapter.createOrder(
               extendedLeverage.toString(),
-              35e-6,
+              34e-6,
               // just in case amount falls short then we need to create a withdrawal
               "BUY" /* BUY */
             );
@@ -98915,7 +98930,7 @@ 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 this.createTransactionResult([], false, params, "NONE");
+              return this.createTransactionResult([], false, params, "NONE", params.cycleType);
             }
           }
           const {
@@ -98929,22 +98944,22 @@ spurious results.`);
             await new Promise((resolve) => setTimeout(resolve, 5e3));
             const { calls, status } = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
             if (calls.length > 0 && status) {
-              return this.createTransactionResult(calls, true, params, "WITHDRAWAL");
+              return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
             } else {
-              return this.createTransactionResult([], true, params, "WITHDRAWAL");
+              return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
             }
           } 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");
+            return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
           } else {
             logger2.error("withdrawal from extended failed");
-            return this.createTransactionResult([], false, params, "NONE");
+            return this.createTransactionResult([], false, params, "NONE", params.cycleType);
           }
         } 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 this.createTransactionResult([], false, params, "NONE");
+            return this.createTransactionResult([], false, params, "NONE", params.cycleType);
           }
           const vesuAmountInBTC = new Web3Number(
             params.amount.dividedBy(collateralPrice.price).toFixed(WBTC_TOKEN_DECIMALS),
@@ -98965,12 +98980,12 @@ spurious results.`);
             await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
           );
           calls.push(swapCall);
-          return this.createTransactionResult(calls, true, params, "WITHDRAWAL");
+          return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
         } 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 this.createTransactionResult([], false, params, "NONE");
+            return this.createTransactionResult([], false, params, "NONE", params.cycleType);
           }
           const vesuAmountInBTC = new Web3Number(
             params.amount.dividedBy(collateralPrice.price).toNumber(),
@@ -99001,23 +99016,31 @@ spurious results.`);
             await proofsInfoDeposit.callConstructor({ amount: params.amount })
           );
           calls.push(callDeposit);
-          return this.createTransactionResult(calls, true, params, "DEPOSIT");
+          return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
         }
         logger2.error(`Unsupported assets movement: ${params.from} to ${params.to}`);
-        return this.createTransactionResult([], false, params, "NONE");
+        return this.createTransactionResult([], false, params, "NONE", params.cycleType);
       } catch (err2) {
         logger2.error(`error moving assets: ${err2}`);
-        return this.createTransactionResult([], false, params, "NONE");
+        return this.createTransactionResult([], false, params, "NONE", params.cycleType);
       }
     }
     async handleDeposit() {
       try {
-        return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE");
+        return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE", "INVESTMENT" /* INVESTMENT */);
       } catch (err2) {
         logger2.error(`error handling deposit: ${err2}`);
-        return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE");
+        return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE", "INVESTMENT" /* INVESTMENT */);
       }
     }
+    /**
+     * Check if the price difference between avnu and extended is within the acceptable range to enhance the position size or close the position
+     * @param extendedAdapter - the extended adapter
+     * @param vesuAdapter - the vesu adapter
+     * @param avnuAdapter - the avnu adapter
+     * @param positionType - the position type (open or close)
+     * @returns true if the price difference is within the acceptable range, false otherwise
+     */
     async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, positionType) {
       const {
         ask,
@@ -99049,6 +99072,11 @@ spurious results.`);
         return result2;
       }
     }
+    /**
+     * Handle the withdrawal of assets from the vault
+     * @param amount - the amount to withdraw in USDC
+     * @returns the calls to be executed and the status of the calls generated along with the metadata for the calls
+     */
     async handleWithdraw(amount) {
       try {
         const usdcBalanceVaultAllocator = await this.getUnusedBalance();
@@ -99061,7 +99089,7 @@ spurious results.`);
             amount: usdcBalanceVaultAllocator.amount
           });
           calls.push(withdrawCall2);
-          return [this.createTransactionResult(calls, true, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "WITHDRAWAL")];
+          return [this.createTransactionResult(calls, true, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "WITHDRAWAL", "WITHDRAWAL" /* WITHDRAWAL */)];
         }
         const vesuAdapter = await this.getVesuAdapter();
         const extendedAdapter = await this.getExtendedAdapter();
@@ -99070,7 +99098,7 @@ spurious results.`);
           logger2.error(
             `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
           );
-          return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
+          return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
         }
         let transactionResults = [];
         const { collateralTokenAmount } = await vesuAdapter.vesuAdapter.getAssetPrices();
@@ -99081,7 +99109,7 @@ spurious results.`);
         if (!extendedPositon) {
           status = false;
           logger2.error("error getting extended position", extendedPositon);
-          return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
+          return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
         }
         const amountDistributionForWithdrawal = await calculateAmountDistributionForWithdrawal(
           usdcBalanceDifference,
@@ -99094,7 +99122,7 @@ spurious results.`);
           logger2.error(
             `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
           );
-          return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
+          return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
         }
         const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
         if (status && vesu_amount.greaterThan(0)) {
@@ -99102,7 +99130,8 @@ spurious results.`);
             {
               amount: vesu_amount,
               from: Protocols.VESU.name,
-              to: Protocols.VAULT.name
+              to: Protocols.VAULT.name,
+              cycleType: "WITHDRAWAL" /* WITHDRAWAL */
             },
             extendedAdapter,
             vesuAdapter
@@ -99119,7 +99148,8 @@ spurious results.`);
             {
               amount: extended_amount,
               from: Protocols.EXTENDED.name,
-              to: Protocols.VAULT.name
+              to: Protocols.VAULT.name,
+              cycleType: "WITHDRAWAL" /* WITHDRAWAL */
             },
             extendedAdapter,
             vesuAdapter
@@ -99133,7 +99163,7 @@ spurious results.`);
             });
           } else {
             logger2.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
-            return [this.createTransactionResult([], status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
+            return [this.createTransactionResult([], status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
           }
         }
         const withdrawCall = await this.getBringLiquidityCall({
@@ -99148,13 +99178,14 @@ spurious results.`);
             protocolTo: Protocols.NONE.name,
             transactionType: "WITHDRAWAL",
             usdAmount: amount.toFixed(),
-            status: "PENDING"
+            status: "PENDING",
+            cycleType: "WITHDRAWAL" /* WITHDRAWAL */
           }
         });
         return transactionResults;
       } catch (err2) {
         logger2.error(`error handling withdrawal: ${err2}`);
-        return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
+        return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
       }
     }
     async getAUM() {
@@ -99231,6 +99262,150 @@ spurious results.`);
         return null;
       }
     }
+    async getMaxBorrowableAmount() {
+      const vesuAdapter = await this.getVesuAdapter();
+      const extendedAdapter = await this.getExtendedAdapter();
+      if (!vesuAdapter || !extendedAdapter) {
+        return new Web3Number(0, 0);
+      }
+      const extendedFundingRate = new Web3Number((await extendedAdapter.getNetAPY()).toFixed(4), 0);
+      const extendedPositions = await extendedAdapter.getAllOpenPositions();
+      if (!extendedPositions || extendedPositions.length === 0) {
+        logger2.info(`no extended positions found`);
+        return new Web3Number(0, 0);
+      }
+      const extendePositionSizeUSD = new Web3Number(extendedPositions[0].value || 0, 0);
+      const vesuPositions = await vesuAdapter.getPositions();
+      const vesuSupplyApy = vesuPositions[0].apy.apy;
+      const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+      const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+      const num1 = extendePositionSizeUSD.multipliedBy(extendedFundingRate);
+      const num2 = vesuCollateralSizeUSD.multipliedBy(vesuSupplyApy);
+      const num3 = vesuDebtSizeUSD.abs();
+      const maxBorrowApy = num1.plus(num2).minus(0.1).dividedBy(num3);
+      const vesuMaxBorrowableAmount = await vesuAdapter.vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxBorrowApy.toNumber());
+      return new Web3Number(vesuMaxBorrowableAmount.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+    }
+    async getVesuHealthFactors() {
+      const vesuAdapter = await this.getVesuAdapter();
+      const extendedAdapter = await this.getExtendedAdapter();
+      if (!vesuAdapter || !extendedAdapter) {
+        return [0, 0];
+      }
+      const vesuPositions = await vesuAdapter.getPositions();
+      const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+      const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+      const actualLtv = vesuDebtSizeUSD.dividedBy(vesuCollateralSizeUSD).abs();
+      logger2.info(`actualLtv: ${actualLtv.toNumber()}`);
+      const maxLtv = new Web3Number(await vesuAdapter.vesuAdapter.getLTVConfig(this.config), 4);
+      const healthFactor = new Web3Number(maxLtv.dividedBy(actualLtv).toFixed(4), 4);
+      logger2.info(`healthFactor: ${healthFactor.toNumber()}`);
+      const extendedBalance = await extendedAdapter.getExtendedDepositAmount();
+      if (!extendedBalance) {
+        return [0, 0];
+      }
+      const extendedLeverage = new Web3Number((Number(extendedBalance.marginRatio) * 100).toFixed(4), 4);
+      logger2.info(`extendedLeverage: ${extendedLeverage.toNumber()}`);
+      return [healthFactor.toNumber(), extendedLeverage.toNumber()];
+    }
+    async netAPY() {
+      const allPositions = [];
+      for (let adapter2 of this.metadata.additionalInfo.adapters) {
+        if (adapter2.adapter.name !== ExtendedAdapter.name) {
+          let positions = await adapter2.adapter.getPositions();
+          if (positions.length > 0) {
+            allPositions.push(...positions);
+          }
+        }
+      }
+      const extendedAdapter = await this.getExtendedAdapter();
+      if (!extendedAdapter) {
+        return {
+          net: 0,
+          splits: []
+        };
+      }
+      let vesuPositions = allPositions.filter((item) => item.protocol === Protocols.VESU);
+      vesuPositions.map((item) => {
+        item.apy.apy = item.apy.apy * 0.1;
+      });
+      const extendedPositions = await extendedAdapter.getAllOpenPositions();
+      const usdcToken = Global.getDefaultTokens().find((token) => token.symbol === "USDC");
+      if (!extendedPositions || !usdcToken) {
+        return {
+          net: 0,
+          splits: []
+        };
+      }
+      const extendedPosition = extendedPositions[0] || 0;
+      const extendedEquity = (await extendedAdapter.getExtendedDepositAmount())?.equity || 0;
+      const extendedApy = await extendedAdapter.getNetAPY();
+      const totalHoldingsUSDValue = allPositions.reduce((acc, curr) => acc + curr.usdValue, 0) + Number(extendedEquity);
+      console.log(totalHoldingsUSDValue);
+      const extendedPositionSizeMultipliedByApy = Number(extendedPosition.value) * extendedApy;
+      let weightedAPYs = allPositions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0) + extendedPositionSizeMultipliedByApy;
+      console.log(weightedAPYs);
+      const netAPY = weightedAPYs / totalHoldingsUSDValue;
+      console.log(netAPY);
+      allPositions.push({
+        tokenInfo: usdcToken,
+        amount: new Web3Number(extendedPosition.size, 0),
+        usdValue: Number(extendedEquity),
+        apy: { apy: extendedApy, type: "base" /* BASE */ },
+        remarks: "finalised" /* FINALISED */,
+        protocol: Protocols.EXTENDED
+      });
+      return {
+        net: netAPY,
+        splits: allPositions.map((p) => ({ apy: p.apy.apy, id: p.remarks ?? "" }))
+      };
+    }
+    async getWalletHoldings() {
+      const usdceToken = Global.getDefaultTokens().find((token) => token.symbol === "USDCe");
+      const wbtcToken = Global.getDefaultTokens().find((token) => token.symbol === "WBTC");
+      const usdcToken = Global.getDefaultTokens().find((token) => token.symbol === "USDC");
+      if (!usdceToken || !wbtcToken || !usdcToken) {
+        return [];
+      }
+      const walletAddress = this.metadata.additionalInfo.walletAddress;
+      const usdceWalletBalance = await new ERC20(this.config).balanceOf(
+        usdceToken.address,
+        walletAddress,
+        usdceToken.decimals
+      );
+      const usdcWalletBalance = await new ERC20(this.config).balanceOf(
+        usdcToken.address,
+        walletAddress,
+        usdcToken.decimals
+      );
+      const wbtcWalletBalance = await new ERC20(this.config).balanceOf(
+        wbtcToken.address,
+        walletAddress,
+        wbtcToken.decimals
+      );
+      const price = await this.pricer.getPrice(usdceToken.symbol);
+      const wbtcPrice = await this.pricer.getPrice(wbtcToken.symbol);
+      const usdceUsdValue = Number(usdceWalletBalance.toFixed(usdceToken.decimals)) * price.price;
+      const usdcUsdValue = Number(usdcWalletBalance.toFixed(usdcToken.decimals)) * price.price;
+      const wbtcUsdValue = Number(wbtcWalletBalance.toFixed(wbtcToken.decimals)) * wbtcPrice.price;
+      return [
+        {
+          tokenInfo: usdceToken,
+          amount: usdceWalletBalance,
+          usdValue: usdceUsdValue
+        },
+        {
+          tokenInfo: usdcToken,
+          amount: usdcWalletBalance,
+          usdValue: usdcUsdValue
+        },
+        {
+          tokenInfo: wbtcToken,
+          amount: wbtcWalletBalance,
+          usdValue: wbtcUsdValue
+        }
+      ];
+    }
   };
   function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
     vaultSettings.leafAdapters = [];
@@ -99405,7 +99580,8 @@ spurious results.`);
       Global.getDefaultTokens().find((token) => token.symbol === "WBTC").decimals
     ),
     borrowable_assets: [Global.getDefaultTokens().find((token) => token.symbol === "WBTC")],
-    minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP
+    minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
+    walletAddress: WALLET_ADDRESS
   };
   var VesuExtendedTestStrategies = (extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) => {
     return [