@strkfarm/sdk 1.1.16 → 1.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.1.16",
+  "version": "1.1.19",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",
@@ -62,6 +62,7 @@
     "@noble/curves": "^1.0.0",
     "@noble/hashes": "^2.0.0",
     "@scure/starknet": "^2.0.0",
+    "@strkfarm/sdk": "link:",
     "bignumber.js": "4.0.4",
     "browser-assert": "^1.2.1",
     "chalk": "^4.1.2",

package/src/dataTypes/_bignumber.ts

@@ -10,27 +10,42 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
   }
 
   toWei() {
-    return this.mul(10 ** this.decimals).toFixed(0);
+    return super.mul(10 ** this.decimals).toFixed(0);
   }
 
   multipliedBy(value: string | number | T): T {
     const _value = this.getStandardString(value);
-    return this.construct(this.mul(_value).toString(), this.decimals);
+    return this.construct(super.mul(_value).toString(), this.decimals);
   }
 
   dividedBy(value: string | number | T): T {
     const _value = this.getStandardString(value);
-    return this.construct(this.div(_value).toString(), this.decimals);
+    return this.construct(super.dividedBy(_value).toString(), this.decimals);
   }
 
   plus(value: string | number | T): T {
-    const _value = this.getStandardString(value);
-    return this.construct(this.add(_value).toString(), this.decimals);
+    // Convert to raw number/string to avoid calling overridden methods
+    const rawValue = this.getStandardString(value);
+    
+    // Create a fresh BigNumber instance to do the math
+    const thisBN = new BigNumber(this.toString());
+    const result = thisBN.plus(rawValue);
+    
+    return this.construct(result.toString(), this.decimals);
+    // const _value = this.getStandardString(value);
+    // return this.construct(super.plus(_value).toString(), this.decimals);
   }
 
   minus(n: number | string | T, base?: number): T {
-    const _value = this.getStandardString(n);
-    return this.construct(super.minus(_value, base).toString(), this.decimals);
+    const rawValue = this.getStandardString(n);
+  
+    // Create a fresh BigNumber instance to do the math
+    const thisBN = new BigNumber(this.toString());
+    const result = thisBN.minus(rawValue, base);
+    
+    return this.construct(result.toString(), this.decimals);
+    // const _value = this.getStandardString(n);
+    // return this.construct(super.minus(_value, base).toString(), this.decimals);
   }
 
   protected construct(value: string | number, decimals: number): T {
@@ -56,10 +71,15 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
   }
 
   private getStandardString(value: string | number | T): string {
-    if (typeof value == "string") {
+    if (typeof value === "string") {
       return value;
     }
-    return value.toFixed(this.maxToFixedDecimals());
+    if (typeof value === "number") {
+      return value.toString();
+    }
+    // For _Web3Number instances, use the parent BigNumber's toString
+    // to avoid triggering our overridden methods
+    return BigNumber.prototype.toString.call(value);
   }
 
   minimum(value: string | number | T): T {
@@ -72,13 +92,11 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
   maximum(value: string | number | T): T {
     const _value = new BigNumber(value);
     const _valueMe = new BigNumber(this.toString());
-    console.warn(`maximum: _value: ${_value.toString()}, _valueMe: ${_valueMe.toString()}`);
     const answer = _value.greaterThanOrEqualTo(_valueMe) ? _value : _valueMe;
     return this.construct(answer.toString(), this.decimals);
   }
 
   abs(): T {
-    console.warn(`abs: this: ${this}`);
     return this.construct(Math.abs(this.toNumber()).toFixed(12), this.decimals);
   }
 

package/src/modules/pricer-from-api.ts

@@ -42,7 +42,7 @@ export class PricerFromApi extends PricerBase {
 
     async getPriceFromMyAPI(tokenSymbol: string) {
         logger.verbose(`getPrice from redis: ${tokenSymbol}`);
-        const endpoint = 'https://cache-server-t2me.onrender.com'
+        const endpoint = 'https://proxy.api.troves.fi'
         const url = `${endpoint}/api/price/${tokenSymbol}`;
         const priceInfoRes = await fetch(url);
         const priceInfo = await priceInfoRes.json();

package/src/modules/pricer.ts

@@ -147,14 +147,14 @@ export class Pricer extends PricerBase {
         logger.verbose(`Fetching price of ${token.symbol} using ${methodToUse}`);
         switch (methodToUse) {
             case 'Coinbase':
-                try {
-                    const result = await this._getPriceCoinbase(token);
-                    this.methodToUse[token.symbol] = 'Coinbase';
-                    return result;
-                } catch (error: any) {
-                    console.warn(`Coinbase: price err: message [${token.symbol}]: `, error.message);
-                    // do nothing, try next
-                }
+                // try {
+                //     const result = await this._getPriceCoinbase(token);
+                //     this.methodToUse[token.symbol] = 'Coinbase';
+                //     return result;
+                // } catch (error: any) {
+                //     console.warn(`Coinbase: price err: message [${token.symbol}]: `, error.message);
+                //     // do nothing, try next
+                // }
             case 'Coinmarketcap':
                 try {
                     const result = await this._getPriceCoinMarketCap(token);

package/src/strategies/base-strategy.ts

@@ -1,5 +1,5 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { IConfig, TokenInfo } from "@/interfaces";
+import { IConfig, TokenInfo, VaultPosition } from "@/interfaces";
 import { CacheClass } from "@/utils/cacheClass";
 import { Call } from "starknet";
 
@@ -51,4 +51,8 @@ export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
     async withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
         throw new Error("Not implemented");
     }
+
+    async getVaultPositions(): Promise<VaultPosition[]> {
+        throw new Error("Not implemented");
+    }
 }

package/src/strategies/constants.ts

@@ -7,5 +7,5 @@ export const COMMON_CONTRACTS = [{
 }];
 
 export const ENDPOINTS = {
-  VESU_BASE: "https://cache-server-t2me.onrender.com/vesu"
+  VESU_BASE: "https://proxy.api.troves.fi/vesu-staging"
 }

package/src/strategies/ekubo-cl-vault.tsx

@@ -11,6 +11,7 @@ import {
   RiskFactor,
   RiskType,
   TokenInfo,
+  VaultPosition,
 } from "@/interfaces";
 import { PricerBase } from "@/modules/pricerBase";
 import { assert } from "@/utils";
@@ -634,6 +635,50 @@ export class EkuboCLVault extends BaseStrategy<
     return this.tickToi129(tick);
   }
 
+  async getVaultPositions(): Promise<VaultPosition[]> {
+    const tvlInfo = await this.getTVL();
+    const fees = await this.getUncollectedFees();
+    const unusedBalance = await this.unusedBalances();
+    return [
+      {
+        amount: tvlInfo.token0.amount,
+        usdValue: tvlInfo.token0.usdValue,
+        token: tvlInfo.token0.tokenInfo,
+        remarks: `Liquidity in Ekubo`
+      },
+      {
+        amount: fees.token0.amount,
+        usdValue: fees.token0.usdValue,
+        token: fees.token0.tokenInfo,
+        remarks: "Uncollected Fees in Ekubo"
+      },
+      {
+        amount: unusedBalance.token0.amount,
+        usdValue: unusedBalance.token0.usdValue,
+        token: unusedBalance.token0.tokenInfo,
+        remarks: "Unused Balance in the Vault"
+      },
+      {
+        amount: tvlInfo.token1.amount,
+        usdValue: tvlInfo.token1.usdValue,
+        token: tvlInfo.token1.tokenInfo,
+        remarks: "Liquidity in Ekubo"
+      },
+      {
+        amount: fees.token1.amount,
+        usdValue: fees.token1.usdValue,
+        token: fees.token1.tokenInfo,
+        remarks: "Uncollected Fees in Ekubo"
+      },
+      {
+        amount: unusedBalance.token1.amount,
+        usdValue: unusedBalance.token1.usdValue,
+        token: unusedBalance.token1.tokenInfo,
+        remarks: "Unused Balance in the Vault" 
+      }
+    ];
+  }
+
   async getPoolKey(
     blockIdentifier: BlockIdentifier = "latest"
   ): Promise<EkuboPoolKey> {

package/src/strategies/universal-adapters/adapter-utils.ts

@@ -3,10 +3,11 @@ import { ContractAddr } from "@/dataTypes";
 // Zellic audited
 export const SIMPLE_SANITIZER = ContractAddr.from('0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4');
 // Without flashloan options
-export const SIMPLE_SANITIZER_V2 = ContractAddr.from('0x5643d54da70a471cd2b6fa37f52ea7a13cc3f3910689a839f8490a663d2208a');
+export const SIMPLE_SANITIZER_V2 = ContractAddr.from('0x7b6f98311af8aa425278570e62abf523e6462eaa01a38c1feab9b2f416492e2');
 export const PRICE_ROUTER = ContractAddr.from('0x05e83Fa38D791d2dba8E6f487758A9687FfEe191A6Cf8a6c5761ab0a110DB837');
 export const AVNU_MIDDLEWARE = ContractAddr.from('0x4a7972ed3f5d1e74a6d6c4a8f467666953d081c8f2270390cc169d50d17cb0d');
 
+export const VESU_SINGLETON = ContractAddr.from('0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160');
 export function toBigInt(value: string | number): bigint {
     if (typeof value === 'string') {
         return BigInt(value);

package/src/strategies/universal-adapters/vesu-adapter.ts

@@ -1,10 +1,10 @@
 import { LeafData, logger  } from "@/utils"
 import { CairoCustomEnum, Contract, hash, num, RpcProvider, shortString, uint256, Uint256 } from "starknet";
-import { SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, toBigInt } from "./adapter-utils";
+import { SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, toBigInt, VESU_SINGLETON } from "./adapter-utils";
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { AdapterLeafType, BaseAdapter, GenerateCallFn, LeafAdapterFn, ManageCall } from "./baseAdapter";
 import VesuSingletonAbi from '../../data/vesu-singleton.abi.json';
-import { IConfig, TokenInfo, VaultPosition } from "@/interfaces";
+import { getMainnetConfig, IConfig, TokenInfo, VaultPosition } from "@/interfaces";
 import { PricerBase } from "@/modules/pricerBase";
 import VesuPoolIDs from "@/data/vesu_pools.json";
 import { getAPIUsingHeadlessBrowser } from "@/node/headless";
@@ -13,6 +13,7 @@ import { VESU_REWARDS_CONTRACT } from "@/modules/harvests";
 import { ENDPOINTS } from "../constants";
 import VesuMultiplyAbi from '@/data/vesu-multiple.abi.json';
 import { EkuboPoolKey } from "../ekubo-cl-vault";
+import VesuPoolV2Abi from '@/data/vesu-pool-v2.abi.json';
 
 interface VesuPoolsInfo { pools: any[]; isErrorPoolsAPI: boolean };
 
@@ -212,12 +213,20 @@ function getVesuMultiplyParams(isIncrease: boolean, params: IncreaseLeverParams
 
 export const VesuPools = {
   Genesis: ContractAddr.from('0x4dc4f0ca6ea4961e4c8373265bfd5317678f4fe374d76f3fd7135f57763bf28'),
-  Re7xSTRK: ContractAddr.from('0x052fb52363939c3aa848f8f4ac28f0a51379f8d1b971d8444de25fbd77d8f161')
+  Re7xSTRK: ContractAddr.from('0x052fb52363939c3aa848f8f4ac28f0a51379f8d1b971d8444de25fbd77d8f161'),
+  Re7xBTC: ContractAddr.from('0x3a8416bf20d036df5b1cf3447630a2e1cb04685f6b0c3a70ed7fb1473548ecf')
+}
+
+export function getVesuSingletonAddress(vesuPool: ContractAddr) {
+  if (vesuPool.eq(VesuPools.Genesis) ||
+      vesuPool.eq(VesuPools.Re7xSTRK)) {
+    return {addr: VESU_SINGLETON, isV2: false};
+  }
+  return {addr: vesuPool, isV2: true}; // Vesu v2
 }
 
 export class VesuAdapter extends BaseAdapter {
-  VESU_SINGLETON = ContractAddr.from("0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160");
-  VESU_MULTIPLY = ContractAddr.from('0x3630f1f8e5b8f5c4c4ae9b6620f8a570ae55cddebc0276c37550e7c118edf67');
+  VESU_MULTIPLY = ContractAddr.from('0x027fef272d0a9a3844767c851a64b36fe4f0115141d81134baade95d2b27b781');
   config: VesuAdapterConfig;
   networkConfig: IConfig | undefined;
   pricer: PricerBase | undefined;
@@ -239,7 +248,7 @@ export class VesuAdapter extends BaseAdapter {
     ];
     const output = this.constructSimpleLeafData({
       id: this.config.id,
-      target: this.VESU_SINGLETON,
+      target: getVesuSingletonAddress(this.config.poolId).addr,
       method: 'modify_position',
       packedArguments
     });
@@ -299,9 +308,15 @@ export class VesuAdapter extends BaseAdapter {
       }
     };
     logger.verbose(`VesuAdapter::ConstructingModify::Debt::${JSON.stringify(_debt)}`)
-    const singletonContract = new Contract({abi: VesuSingletonAbi, address: this.VESU_SINGLETON.toString(), providerOrAccount: new RpcProvider({nodeUrl: ''})});
-    const call = singletonContract.populate('modify_position', {
-      params: {
+    const { contract, isV2 } = this.getVesuSingletonContract(getMainnetConfig(), this.config.poolId);
+    const call = contract.populate('modify_position', {
+      params: isV2 ? {
+        collateral_asset: this.config.collateral.address.toBigInt(),
+        debt_asset: this.config.debt.address.toBigInt(),
+        user: this.config.vaultAllocator.toBigInt(),
+        collateral: _collateral,
+        debt: _debt,
+      } : {
         pool_id: this.config.poolId.toBigInt(),
         collateral_asset: this.config.collateral.address.toBigInt(),
         debt_asset: this.config.debt.address.toBigInt(),
@@ -314,7 +329,7 @@ export class VesuAdapter extends BaseAdapter {
     return {
       sanitizer: SIMPLE_SANITIZER,
       call: {
-        contractAddress: this.VESU_SINGLETON,
+        contractAddress: ContractAddr.from(contract.address),
         selector: hash.getSelectorFromName('modify_position'),
         calldata: [
           ...call.calldata as bigint[]
@@ -372,12 +387,11 @@ export class VesuAdapter extends BaseAdapter {
   getVesuModifyDelegationAdapter = (id: string): LeafAdapterFn<VesuModifyDelegationCallParams> => {
     return () => {
       const packedArguments: bigint[] = [
-        toBigInt(this.config.poolId.toString()), // pool id
         toBigInt(this.VESU_MULTIPLY.toString()), // vault allocator
       ];
       const output = this.constructSimpleLeafData({
         id: id,
-        target: this.VESU_SINGLETON,
+        target: getVesuSingletonAddress(this.config.poolId).addr,
         method: 'modify_delegation',
         packedArguments
       }, SIMPLE_SANITIZER_V2);
@@ -387,8 +401,12 @@ export class VesuAdapter extends BaseAdapter {
   }
 
   getVesuModifyDelegationCall = (params: VesuModifyDelegationCallParams): ManageCall => {
-    const singletonContract = new Contract({abi: VesuSingletonAbi, address: this.VESU_SINGLETON.toString(), providerOrAccount: new RpcProvider({nodeUrl: ''})});
-    const call = singletonContract.populate('modify_delegation', {
+    const VESU_SINGLETON = getVesuSingletonAddress(this.config.poolId).addr;
+    const { contract, isV2 } = this.getVesuSingletonContract(getMainnetConfig(), this.config.poolId);
+    const call = contract.populate('modify_delegation', isV2 ? {
+      delegatee: this.VESU_MULTIPLY.toBigInt(),
+      delegation: params.delegation,
+    } : {
       pool_id: this.config.poolId.toBigInt(),
       delegatee: this.VESU_MULTIPLY.toBigInt(),
       delegation: params.delegation,
@@ -396,7 +414,7 @@ export class VesuAdapter extends BaseAdapter {
     return {
       sanitizer: SIMPLE_SANITIZER_V2,
       call: {
-        contractAddress: this.VESU_SINGLETON,
+        contractAddress: VESU_SINGLETON,
         selector: hash.getSelectorFromName('modify_delegation'),
         calldata: [
           ...call.calldata as bigint[]
@@ -458,8 +476,13 @@ export class VesuAdapter extends BaseAdapter {
     throw new Error(`Unknown VesuAmountDenomination: ${denomination}`);
   }
 
-  getVesuSingletonContract(config: IConfig) {
-    return new Contract({abi: VesuSingletonAbi, address: this.VESU_SINGLETON.address, providerOrAccount: config.provider});
+  getVesuSingletonContract(config: IConfig, poolId: ContractAddr) {
+    const { addr: VESU_SINGLETON, isV2 } = getVesuSingletonAddress(poolId);
+    const ABI = isV2 ? VesuPoolV2Abi : VesuSingletonAbi;
+    return {
+      contract: new Contract({abi: ABI, address: VESU_SINGLETON.address, providerOrAccount: config.provider}),
+      isV2
+    }
   }
 
   async getLTVConfig(config: IConfig) {
@@ -468,9 +491,16 @@ export class VesuAdapter extends BaseAdapter {
     if (cacheData) {
       return cacheData as number;
     }
-    const output: any = await this.getVesuSingletonContract(config)
-      .call('ltv_config', [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address])
-    this.setCache(CACHE_KEY, Number(output.max_ltv) / 1e18, 300000); // ttl: 5min
+    const { contract, isV2 } = await this.getVesuSingletonContract(config, this.config.poolId);
+    let ltv = 0;
+    if (isV2) {
+      const output: any = await contract.call('pair_config', [this.config.collateral.address.address, this.config.debt.address.address]);
+      ltv = Number(output.max_ltv) / 1e18;
+    } else {
+      const output: any = await contract.call('ltv_config', [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
+      ltv = Number(output.max_ltv) / 1e18;
+    }
+    this.setCache(CACHE_KEY, ltv, 300000); // ttl: 5min
     return this.getCache<number>(CACHE_KEY) as number;
   }
 
@@ -484,9 +514,11 @@ export class VesuAdapter extends BaseAdapter {
     if (cacheData) {
       return cacheData;
     }
-    const output: any = await this.getVesuSingletonContract(config)
-      .call('position_unsafe', [
-        this.config.poolId.address,
+
+    const { contract, isV2} = this.getVesuSingletonContract(config, this.config.poolId);
+    const output: any = await contract
+      .call(isV2 ? 'position' : 'position_unsafe', [...(isV2 ? 
+        []: [this.config.poolId.address]), // exclude pool id in v2
         this.config.collateral.address.address,
         this.config.debt.address.address,
         this.config.vaultAllocator.address
@@ -494,7 +526,8 @@ export class VesuAdapter extends BaseAdapter {
 
     const token1Price = await this.pricer.getPrice(this.config.collateral.symbol);
     const token2Price = await this.pricer.getPrice(this.config.debt.symbol);
-
+    logger.verbose(`VesuAdapter::getPositions token1Price: ${token1Price.price}, token2Price: ${token2Price.price}`);
+    
     const collateralAmount = Web3Number.fromWei(output['1'].toString(), this.config.collateral.decimals);
     const debtAmount = Web3Number.fromWei(output['2'].toString(), this.config.debt.decimals);
     const value = [{
@@ -522,9 +555,11 @@ export class VesuAdapter extends BaseAdapter {
     if (cacheData) {
       return cacheData;
     }
-    const output: any = await this.getVesuSingletonContract(config)
-      .call('check_collateralization_unsafe', [
-        this.config.poolId.address,
+    const { contract, isV2 } = this.getVesuSingletonContract(config, this.config.poolId);
+    const output: any = await contract
+      .call(isV2 ? 'check_collateralization' : 'check_collateralization_unsafe', [
+        ...(isV2 ? 
+          []: [this.config.poolId.address]), // exclude pool id in v2
         this.config.collateral.address.address,
         this.config.debt.address.address,
         this.config.vaultAllocator.address
@@ -598,7 +633,7 @@ export class VesuAdapter extends BaseAdapter {
 
         // Vesu API is unstable sometimes, some Pools may be missing sometimes
         for (const pool of VesuPoolIDs.data) {
-          const found = pools.find((d: any) => d.id === pool.id);
+          const found = pools.find((d: any) => ContractAddr.from(d.id).eqString(pool.id));
           if (!found) {
             logger.verbose(`VesuRebalance: pools: ${JSON.stringify(pools)}`);
             logger.verbose(

package/src/strategies/universal-lst-muliplier-strategy.tsx

@@ -17,7 +17,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
   
   private quoteAmountToFetchPrice = new Web3Number(1, 18);
   
-  constructor(config: IConfig, pricer: PricerLST, metadata: IStrategyMetadata<UniversalStrategySettings>) {
+  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<UniversalStrategySettings>) {
     super(config, pricer, metadata);
 
     const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
@@ -30,8 +30,17 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     }
   }
 
+  asset() {
+    const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
+    return vesuAdapter1.config.collateral;
+  }
+
+  getTag() {
+    return `${UniversalLstMultiplierStrategy.name}:${this.metadata.name}`;
+  }
+
   // only one leg is used
-  // todo support lending assets of underlying as well
+  // todo support lending assets of underlying as well (like if xSTRK looping is not viable, simply supply STRK)
   getVesuAdapters() {
     const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
     vesuAdapter1.pricer = this.pricer;
@@ -42,9 +51,13 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
 
   // not applicable for this strategy
   // No rewards on collateral or borrowing of LST assets
-  // protected async getRewardsAUM(prevAum: Web3Number): Promise<Web3Number> {
-  //   return Web3Number.fromWei("0", this.asset().decimals);
-  // }
+  protected async getRewardsAUM(prevAum: Web3Number): Promise<Web3Number> {
+    const lstToken = this.asset();
+    if (lstToken.symbol === 'xSTRK') {
+      return super.getRewardsAUM(prevAum);
+    }
+    return Web3Number.fromWei("0", lstToken.decimals);
+  }
 
   async getLSTDexPrice() {
     const ekuboQuoter = new EkuboQuoter(this.config);
@@ -74,6 +87,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
   }) {
     const [vesuAdapter1] = this.getVesuAdapters();
     const legLTV = await vesuAdapter1.getLTVConfig(this.config);
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall legLTV: ${legLTV}`);
 
     const existingPositions = await vesuAdapter1.getPositions(this.config);
     const collateralisation = await vesuAdapter1.getCollateralization(this.config);
@@ -103,8 +117,11 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
       .multipliedBy(params.isDeposit ? 1 : -1)
     logger.verbose(`${this.getTag()}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`);
     const numeratorPart1 = (existingCollateralInfo.amount.plus((addedCollateral))).multipliedBy(collateralPrice).multipliedBy(legLTV);
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}`);
     const numeratorPart2 = existingDebtInfo.amount.multipliedBy(debtPrice).multipliedBy(this.metadata.additionalInfo.targetHealthFactor);
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall numeratorPart2: ${numeratorPart2}`);
     const denominatorPart = this.metadata.additionalInfo.targetHealthFactor - (legLTV / dexPrice);
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall denominatorPart: ${denominatorPart}`);
     const x_debt_usd = numeratorPart1.minus(numeratorPart2).dividedBy(denominatorPart);
     logger.verbose(`${this.getTag()}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`);
     logger.debug(`${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}, numeratorPart2: ${numeratorPart2}, denominatorPart: ${denominatorPart}`);
@@ -159,12 +176,20 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     lstDexPriceInUnderlying: number,
     isIncrease: boolean
   }): Promise<Call[]> {
+    logger.verbose(`${this.getTag()}::getModifyLeverCall marginAmount: ${params.marginAmount}, debtAmount: ${params.debtAmount}, lstDexPriceInUnderlying: ${params.lstDexPriceInUnderlying}, isIncrease: ${params.isIncrease}`);
     assert(!params.marginAmount.isZero() || !params.debtAmount.isZero(), 'Deposit/debt must be non-0');
-    
+
     const [vesuAdapter1] = this.getVesuAdapters();
     const lstTokenInfo = this.asset();
     const lstUnderlyingTokenInfo = vesuAdapter1.config.debt;
 
+    // todo make it more general
+    // 500k STRK (~75k$) or 0.5 BTC (~60k$)
+    const maxAmounts = lstTokenInfo.symbol == 'xSTRK' ? 500000 : 0.5;
+    if (params.marginAmount.greaterThan(maxAmounts)) {
+      throw new Error(`Margin amount is greater than max amount: ${params.marginAmount.toNumber()} > ${maxAmounts}`);
+    }
+
     const proofsIDs: string[] = [];
     const manageCalls: ManageCall[] = [];
 
@@ -181,13 +206,11 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     }
 
     const lstDexPriceInUnderlying = params.lstDexPriceInUnderlying;
+    const lstTrueExchangeRate = await this.getLSTExchangeRate();
     const ekuboQuoter = new EkuboQuoter(this.config);
 
-    // compute quotes for margin swap
-    const marginSwap: Swap[] = [];
-
     // compute quotes for lever swap
-    const MAX_SLIPPAGE = 0.01;
+    const MAX_SLIPPAGE = 0.002;
     // when increasing, debt is swapped to collateral (LST)
     // when decreasing, collateral is swapped to debt (underlying)
     // but both cases, we denominate amount in underlying. negative for decrease (exact amount out)
@@ -198,11 +221,29 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
       toToken.address.address, 
       params.debtAmount // negative for exact amount out
     );
-    assert(leverSwapQuote.price_impact < MAX_SLIPPAGE, 'getIncreaseLeverCall: Price impact is too high [Debt swap]');
+    logger.verbose(`${this.getTag()}::getModifyLeverCall leverSwapQuote: ${JSON.stringify(leverSwapQuote)}`);
+    // Ekubo's price impact can randomly show high numbers sometimes. 
+    assert(leverSwapQuote.price_impact < 0.01, 'getIncreaseLeverCall: Price impact is too high [Debt swap]');
     const leverSwap = ekuboQuoter.getVesuMultiplyQuote(leverSwapQuote, fromToken, toToken);
-    const minExpectedDebt = params.debtAmount.dividedBy(lstDexPriceInUnderlying).multipliedBy(1 - MAX_SLIPPAGE); // used for increase
-    const maxUsedCollateral = params.debtAmount.abs().dividedBy(lstDexPriceInUnderlying).multipliedBy(1 + MAX_SLIPPAGE); // +ve for exact amount out, used for decrease
-   
+    logger.verbose(`${this.getTag()}::getModifyLeverCall leverSwap: ${JSON.stringify(leverSwap)}`);
+
+    // todo double check this logic
+    // is Deposit
+    let minLSTReceived = params.debtAmount.dividedBy(lstDexPriceInUnderlying).multipliedBy(1 - MAX_SLIPPAGE); // used for increase
+    const minLSTReceivedAsPerTruePrice = params.debtAmount.dividedBy(lstTrueExchangeRate); // execution output to be <= True LST price
+    if (minLSTReceived < minLSTReceivedAsPerTruePrice) {
+      minLSTReceived = minLSTReceivedAsPerTruePrice; // the execution shouldn't be bad than True price logi
+    }
+    logger.verbose(`${this.getTag()}::getModifyLeverCall minLSTReceivedAsPerTruePrice: ${minLSTReceivedAsPerTruePrice}, minLSTReceived: ${minLSTReceived}`);
+
+    // is withdraw
+    let maxUsedCollateral = params.debtAmount.abs().dividedBy(lstDexPriceInUnderlying).multipliedBy(1 + MAX_SLIPPAGE); // +ve for exact amount out, used for decrease
+    const maxUsedCollateralInLST = params.debtAmount.abs().dividedBy(lstTrueExchangeRate).multipliedBy(1.005); // 0.5% slippage, worst case based on true price
+    logger.verbose(`${this.getTag()}::getModifyLeverCall maxUsedCollateralInLST: ${maxUsedCollateralInLST}, maxUsedCollateral: ${maxUsedCollateral}`);
+    if (maxUsedCollateralInLST > maxUsedCollateral) {
+      maxUsedCollateral = maxUsedCollateralInLST;
+    }
+
     const STEP2_ID = LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON;
     const manage2Info = this.getProofs<VesuModifyDelegationCallParams>(STEP2_ID);
     const manageCall2 = manage2Info.callConstructor({
@@ -216,10 +257,10 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
       isIncrease: true,
       increaseParams: {
         add_margin: params.marginAmount,
-        margin_swap: marginSwap,
+        margin_swap: [],
         margin_swap_limit_amount: Web3Number.fromWei(0, this.asset().decimals),
         lever_swap: leverSwap,
-        lever_swap_limit_amount: minExpectedDebt
+        lever_swap_limit_amount: minLSTReceived
       }
     } : {
       isIncrease: false,
@@ -425,7 +466,7 @@ const hyperxWBTC: UniversalStrategySettings = {
   manager: ContractAddr.from('0x75866db44c81e6986f06035206ee9c7d15833ddb22d6a22c016cfb5c866a491'),
   vaultAllocator: ContractAddr.from('0x57b5c1bb457b5e840a2714ae53ada87d77be2f3fd33a59b4fe709ef20c020c1'),
   redeemRequestNFT: ContractAddr.from('0x7a5dc288325456f05e70e9616e16bc02ffbe448f4b89f80b47c0970b989c7c'),
-  aumOracle: ContractAddr.from(''),
+  aumOracle: ContractAddr.from('0x258f8a0ca0d21f542e48ad89d00e92dc4d9db4999084f50ef9c22dfb1e83023'),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
@@ -437,7 +478,7 @@ const hyperxtBTC: UniversalStrategySettings = {
   manager: ContractAddr.from('0xc4cc3e08029a0ae076f5fdfca70575abb78d23c5cd1c49a957f7e697885401'),
   vaultAllocator: ContractAddr.from('0x50bbd4fe69f841ecb13b2619fe50ebfa4e8944671b5d0ebf7868fd80c61b31e'),
   redeemRequestNFT: ContractAddr.from('0xeac9032f02057779816e38a6cb9185d12d86b3aacc9949b96b36de359c1e3'),
-  aumOracle: ContractAddr.from(''),
+  aumOracle: ContractAddr.from('0x7e0d05cb7ba3f7db77a36c21c21583b5a524c2e685c08c24b3554911fb4a039'),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
@@ -449,7 +490,7 @@ const hyperxsBTC: UniversalStrategySettings = {
   manager: ContractAddr.from('0xc9ac023090625b0be3f6532ca353f086746f9c09f939dbc1b2613f09e5f821'),
   vaultAllocator: ContractAddr.from('0x60c2d856936b975459a5b4eb28b8672d91f757bd76cebb6241f8d670185dc01'),
   redeemRequestNFT: ContractAddr.from('0x429e8ee8bc7ecd1ade72630d350a2e0f10f9a2507c45f188ba17fe8f2ab4cf3'),
-  aumOracle: ContractAddr.from(''),
+  aumOracle: ContractAddr.from('0x149298ade3e79ec6cbdac6cfad289c57504eaf54e590939136ed1ceca60c345'),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
@@ -487,7 +528,7 @@ function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addres
     launchBlock: 0,
     type: 'Other',
     depositTokens: [Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!],
-    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, addresses, VesuPools.Re7xSTRK),
+    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, addresses, lstSymbol === 'xSTRK' ? VesuPools.Re7xSTRK : VesuPools.Re7xBTC),
     risk: {
       riskFactor: _riskFactor,
       netRisk:
@@ -507,8 +548,8 @@ function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addres
 export const HyperLSTStrategies: IStrategyMetadata<UniversalStrategySettings>[] =
   [
     getStrategySettings('xSTRK', 'STRK', hyperxSTRK, false),
-    getStrategySettings('xWBTC', 'WBTC', hyperxWBTC, true),
-    getStrategySettings('xtBTC', 'tBTC', hyperxtBTC, true),
-    getStrategySettings('xsBTC', 'solvBTC', hyperxsBTC, true),
-    getStrategySettings('xLBTC', 'LBTC', hyperxLBTC, true),
+    getStrategySettings('xWBTC', 'WBTC', hyperxWBTC, false),
+    getStrategySettings('xtBTC', 'tBTC', hyperxtBTC, false),
+    getStrategySettings('xsBTC', 'solvBTC', hyperxsBTC, false),
+    getStrategySettings('xLBTC', 'LBTC', hyperxLBTC, false),
   ]