@strkfarm/sdk 1.1.8 → 1.1.9

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

@@ -35,7 +35,7 @@ import { log } from "winston";
 import { EkuboHarvests } from "@/modules/harvests";
 import { logger } from "@/utils/logger";
 import { COMMON_CONTRACTS } from "./constants";
-import { ImpermanentLossLevel, MarketRiskLevel, SmartContractRiskLevel } from "@/interfaces/risks";
+import { DepegRiskLevel, ImpermanentLossLevel, MarketRiskLevel, SmartContractRiskLevel } from "@/interfaces/risks";
 
 export interface EkuboPoolKey {
   token0: ContractAddr;
@@ -1591,22 +1591,30 @@ const _protocol: IProtocol = {
   logo: "https://app.ekubo.org/favicon.ico",
 };
 // need to fine tune better
-const _corelatedPoolRiskFactors: RiskFactor[] = [
+const _lstPoolRiskFactors: RiskFactor[] = [
   { type: RiskType.SMART_CONTRACT_RISK, value: SmartContractRiskLevel.WELL_AUDITED, weight: 34, reason: "Audited smart contracts" },
   { type: RiskType.IMPERMANENT_LOSS, value: ImpermanentLossLevel.HIGHLY_CORRELATED, weight: 33, reason: "Low risk due to co-related assets" },
   { type: RiskType.MARKET_RISK, value: MarketRiskLevel.VERY_LOW_VOLATILITY, weight: 33, reason: "Low risk due to co-related assets" },
+  {type: RiskType.DEPEG_RISK, value: DepegRiskLevel.GENERALLY_STABLE, weight: 33, reason: "Generally stable pegged assets" },
+];
+
+const _stableCoinPoolRiskFactors: RiskFactor[] = [
+  { type: RiskType.SMART_CONTRACT_RISK, value: SmartContractRiskLevel.BATTLE_TESTED, weight: 34, reason: "Audited smart contracts" },
+  { type: RiskType.IMPERMANENT_LOSS, value: ImpermanentLossLevel.HIGHLY_CORRELATED, weight: 33, reason: "Low risk due to co-related assets" },
+  { type: RiskType.MARKET_RISK, value: MarketRiskLevel.VERY_LOW_VOLATILITY, weight: 33, reason: "Low risk due to co-related assets" },
+  {type: RiskType.DEPEG_RISK, value: DepegRiskLevel.HIGHLY_STABLE, weight: 33, reason: "Highly stable assets" },
 ];
 
 const mediumVolatilityPoolRiskFactors: RiskFactor[] = [
   { type: RiskType.SMART_CONTRACT_RISK, value: SmartContractRiskLevel.WELL_AUDITED, weight: 34, reason: "Audited smart contracts" },
-  { type: RiskType.IMPERMANENT_LOSS, value: ImpermanentLossLevel.NON_CORRELATED, weight: 33, reason: "Low risk due to co-related assets" },
-  { type: RiskType.MARKET_RISK, value: MarketRiskLevel.MODERATE_VOLATILITY, weight: 33, reason: "Low risk due to co-related assets" },
+  { type: RiskType.IMPERMANENT_LOSS, value: ImpermanentLossLevel.NON_CORRELATED, weight: 33, reason: "Assets are not correlated, often volatile" },
+  { type: RiskType.MARKET_RISK, value: MarketRiskLevel.MODERATE_VOLATILITY, weight: 33, reason: "Assets are not correlated, relative volatile can be moderate sometimes" },
 ];
 
 const highVolatilityPoolRiskFactors: RiskFactor[] = [
   { type: RiskType.SMART_CONTRACT_RISK, value: SmartContractRiskLevel.WELL_AUDITED, weight: 34, reason: "Audited smart contracts" },
-  { type: RiskType.IMPERMANENT_LOSS, value: ImpermanentLossLevel.NON_CORRELATED, weight: 33, reason: "Low risk due to co-related assets" },
-  { type: RiskType.MARKET_RISK, value: MarketRiskLevel.HIGH_VOLATILITY, weight: 33, reason: "Low risk due to co-related assets" },
+  { type: RiskType.IMPERMANENT_LOSS, value: ImpermanentLossLevel.NON_CORRELATED, weight: 33, reason: "Assets are not correlated, often volatile" },
+  { type: RiskType.MARKET_RISK, value: MarketRiskLevel.HIGH_VOLATILITY, weight: 33, reason: "Assets are not correlated, relative volatile is often high" },
 ];
 
 const mediumRisk = {
@@ -1696,11 +1704,11 @@ const xSTRKSTRK: IStrategyMetadata<CLVaultStrategySettings> = {
   auditUrl: AUDIT_URL,
   maxTVL: Web3Number.fromWei("0", 18),
   risk: {
-    riskFactor: _corelatedPoolRiskFactors,
+    riskFactor: _lstPoolRiskFactors,
     netRisk:
-    _corelatedPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
-    _corelatedPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
-    notARisks: getNoRiskTags(_corelatedPoolRiskFactors),
+    _lstPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
+    _lstPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
+    notARisks: getNoRiskTags(_lstPoolRiskFactors),
   },
   apyMethodology:
     "APY based on 30-day historical performance, including fees and rewards.",
@@ -1858,7 +1866,13 @@ const RE7Strategies: IStrategyMetadata<CLVaultStrategySettings>[] = [
       Global.getDefaultTokens().find((t) => t.symbol === "USDC")!,
       Global.getDefaultTokens().find((t) => t.symbol === "USDT")!
     ],
-    risk: xSTRKSTRK.risk,
+    risk: {
+      riskFactor: _stableCoinPoolRiskFactors,
+      netRisk:
+      _stableCoinPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
+      _stableCoinPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
+      notARisks: getNoRiskTags(_stableCoinPoolRiskFactors),
+    }
   },
   {
     ...ETHUSDCRe7Strategy,

package/src/strategies/index.ts

@@ -4,4 +4,5 @@ export * from './ekubo-cl-vault';
 export * from './base-strategy';
 export * from './sensei';
 export * from './universal-adapters';
-export * from './universal-strategy';
+export * from './universal-strategy';
+export * from './universal-lst-muliplier-strategy';

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

@@ -1,6 +1,9 @@
 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 PRICE_ROUTER = ContractAddr.from('0x05e83Fa38D791d2dba8E6f487758A9687FfEe191A6Cf8a6c5761ab0a110DB837');
 export const AVNU_MIDDLEWARE = ContractAddr.from('0x4a7972ed3f5d1e74a6d6c4a8f467666953d081c8f2270390cc169d50d17cb0d');
 

package/src/strategies/universal-adapters/baseAdapter.ts

@@ -23,14 +23,14 @@ export class BaseAdapter extends CacheClass {
     id: string,
     target: ContractAddr,
     method: string,
-    packedArguments: bigint[]
-  }): LeafData {
+    packedArguments: bigint[],
+  }, sanitizer: ContractAddr = SIMPLE_SANITIZER): LeafData {
     const { id, target, method, packedArguments } = params;
     return {
       id: BigInt(num.getDecimalString(shortString.encodeShortString(id))),
       readableId: id,
       data: [
-        SIMPLE_SANITIZER.toBigInt(), // sanitizer address
+        sanitizer.toBigInt(), // sanitizer address
         target.toBigInt(), // contract
         toBigInt(hash.getSelectorFromName(method)), // method name
         BigInt(packedArguments.length),

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

@@ -1,8 +1,8 @@
 import { LeafData, logger  } from "@/utils"
 import { CairoCustomEnum, Contract, hash, num, RpcProvider, shortString, uint256, Uint256 } from "starknet";
-import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import { SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, toBigInt } from "./adapter-utils";
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { AdapterLeafType, BaseAdapter, GenerateCallFn, ManageCall } from "./baseAdapter";
+import { AdapterLeafType, BaseAdapter, GenerateCallFn, LeafAdapterFn, ManageCall } from "./baseAdapter";
 import VesuSingletonAbi from '../../data/vesu-singleton.abi.json';
 import { IConfig, TokenInfo, VaultPosition } from "@/interfaces";
 import { PricerBase } from "@/modules/pricerBase";
@@ -11,6 +11,8 @@ import { getAPIUsingHeadlessBrowser } from "@/node/headless";
 import { Global } from "@/global";
 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";
 
 interface VesuPoolsInfo { pools: any[]; isErrorPoolsAPI: boolean };
 
@@ -53,12 +55,169 @@ export interface VesuAdapterConfig {
   id: string
 }
 
+export interface TokenAmount {
+  token: ContractAddr,
+  amount: Web3Number, // i129
+}
+export interface Swap {
+  route: RouteNode[],
+  token_amount: TokenAmount,
+}
+
+export interface RouteNode {
+  pool_key: EkuboPoolKey,
+  sqrt_ratio_limit: Web3Number, // u256
+  skip_ahead: Web3Number, // u128
+}
+
+export interface IncreaseLeverParams {
+  pool_id: ContractAddr,
+  collateral_asset: ContractAddr,
+  debt_asset: ContractAddr,
+  user: ContractAddr,
+  add_margin: Web3Number,
+  margin_swap: Swap[],
+  margin_swap_limit_amount: Web3Number,
+  lever_swap: Swap[],
+  lever_swap_limit_amount: Web3Number,
+}
+
+export interface DecreaseLeverParams {
+  pool_id: ContractAddr,
+  collateral_asset: ContractAddr,
+  debt_asset: ContractAddr,
+  user: ContractAddr,
+  sub_margin: Web3Number,
+  recipient: ContractAddr,
+  lever_swap: Swap[],
+  lever_swap_limit_amount: Web3Number,
+  lever_swap_weights: Web3Number[],
+  withdraw_swap: Swap[],
+  withdraw_swap_limit_amount: Web3Number,
+  withdraw_swap_weights: Web3Number[],
+  close_position: boolean,
+}
+
+export interface VesuMultiplyCallParams {
+  increaseParams?: Omit<IncreaseLeverParams, 'user' | 'pool_id' | 'collateral_asset' | 'debt_asset'>,
+  decreaseParams?: Omit<DecreaseLeverParams, 'user' | 'pool_id' | 'collateral_asset' | 'debt_asset' | 'recipient'>,
+  isIncrease: boolean,
+}
+
+export interface VesuModifyDelegationCallParams {
+  delegation: boolean, // is on/off
+}
+
+function getVesuMultiplyParams(isIncrease: boolean, params: IncreaseLeverParams | DecreaseLeverParams) {
+  if (isIncrease) {
+    const _params = params as IncreaseLeverParams;
+    return {
+      action: new CairoCustomEnum({ IncreaseLever: {
+        pool_id: _params.pool_id.toBigInt(),
+        collateral_asset: _params.collateral_asset.toBigInt(),
+        debt_asset: _params.debt_asset.toBigInt(),
+        user: _params.user.toBigInt(),
+        add_margin: BigInt(_params.add_margin.toWei()),
+        margin_swap: _params.margin_swap.map(swap => ({
+          route: swap.route.map(route => ({
+            pool_key: {
+              token0: route.pool_key.token0.toBigInt(),
+              token1: route.pool_key.token1.toBigInt(),
+              fee: route.pool_key.fee,
+              tick_spacing: route.pool_key.tick_spacing,
+              extension: BigInt(num.hexToDecimalString(route.pool_key.extension)),
+            },
+            sqrt_ratio_limit: uint256.bnToUint256(route.sqrt_ratio_limit.toWei()),
+            skip_ahead: BigInt(100)
+          })),
+          token_amount: {
+            token: swap.token_amount.token.toBigInt(),
+            amount: swap.token_amount.amount.toI129()
+          }
+        })),
+        margin_swap_limit_amount: BigInt(_params.margin_swap_limit_amount.toWei()),
+        lever_swap: _params.lever_swap.map(swap => ({
+          route: swap.route.map(route => ({
+            pool_key: {
+              token0: route.pool_key.token0.toBigInt(),
+              token1: route.pool_key.token1.toBigInt(),
+              fee: route.pool_key.fee,
+              tick_spacing: route.pool_key.tick_spacing,
+              extension: BigInt(num.hexToDecimalString(route.pool_key.extension)),
+            },
+            sqrt_ratio_limit: uint256.bnToUint256(route.sqrt_ratio_limit.toWei()),
+            skip_ahead: BigInt(100)
+          })),
+          token_amount: {
+            token: swap.token_amount.token.toBigInt(),
+            amount: swap.token_amount.amount.toI129()
+          }
+        })),
+        lever_swap_limit_amount: BigInt(_params.lever_swap_limit_amount.toWei()),
+      } }),
+    }
+  }
+
+  const _params = params as DecreaseLeverParams;  
+  return {
+    action: new CairoCustomEnum({ DecreaseLever: {
+      pool_id: _params.pool_id.toBigInt(),
+      collateral_asset: _params.collateral_asset.toBigInt(),
+      debt_asset: _params.debt_asset.toBigInt(),
+      user: _params.user.toBigInt(),
+      sub_margin: BigInt(_params.sub_margin.toWei()),
+      recipient: _params.recipient.toBigInt(),
+      lever_swap: _params.lever_swap.map(swap => ({
+        route: swap.route.map(route => ({
+          pool_key: {
+            token0: route.pool_key.token0.toBigInt(),
+            token1: route.pool_key.token1.toBigInt(),
+            fee: route.pool_key.fee,
+            tick_spacing: route.pool_key.tick_spacing,
+            extension: ContractAddr.from(route.pool_key.extension).toBigInt(),
+          },
+          sqrt_ratio_limit: uint256.bnToUint256(route.sqrt_ratio_limit.toWei()),
+          skip_ahead: BigInt(route.skip_ahead.toWei())
+        })),
+        token_amount: {
+          token: swap.token_amount.token.toBigInt(),
+          amount: swap.token_amount.amount.toI129()
+        }
+      })),
+      lever_swap_limit_amount: BigInt(_params.lever_swap_limit_amount.toWei()),
+      lever_swap_weights: _params.lever_swap_weights.map(weight => BigInt(weight.toWei())),
+      withdraw_swap: _params.withdraw_swap.map(swap => ({
+        route: swap.route.map(route => ({
+          pool_key: {
+            token0: route.pool_key.token0.toBigInt(),
+            token1: route.pool_key.token1.toBigInt(),
+            fee: route.pool_key.fee,
+            tick_spacing: route.pool_key.tick_spacing,
+            extension: ContractAddr.from(route.pool_key.extension).toBigInt(),
+          },
+          sqrt_ratio_limit: uint256.bnToUint256(route.sqrt_ratio_limit.toWei()),
+          skip_ahead: BigInt(route.skip_ahead.toWei())
+        })),
+        token_amount: {
+          token: swap.token_amount.token.toBigInt(),
+          amount: swap.token_amount.amount.toI129()
+        }
+      })),
+      withdraw_swap_limit_amount: BigInt(_params.withdraw_swap_limit_amount.toWei()),
+      withdraw_swap_weights: _params.withdraw_swap_weights.map(weight => BigInt(weight.toWei())),
+      close_position: _params.close_position,
+    }}),
+  }
+}
+
 export const VesuPools = {
-  Genesis: ContractAddr.from('0x4dc4f0ca6ea4961e4c8373265bfd5317678f4fe374d76f3fd7135f57763bf28')
+  Genesis: ContractAddr.from('0x4dc4f0ca6ea4961e4c8373265bfd5317678f4fe374d76f3fd7135f57763bf28'),
+  Re7xSTRK: ContractAddr.from('0x052fb52363939c3aa848f8f4ac28f0a51379f8d1b971d8444de25fbd77d8f161')
 }
 
 export class VesuAdapter extends BaseAdapter {
   VESU_SINGLETON = ContractAddr.from("0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160");
+  VESU_MULTIPLY = ContractAddr.from('0x3630f1f8e5b8f5c4c4ae9b6620f8a570ae55cddebc0276c37550e7c118edf67');
   config: VesuAdapterConfig;
   networkConfig: IConfig | undefined;
   pricer: PricerBase | undefined;
@@ -163,6 +322,88 @@ export class VesuAdapter extends BaseAdapter {
       }
     }
   }
+
+  getMultiplyAdapter = (): AdapterLeafType<VesuMultiplyCallParams> => {
+    const packedArguments: bigint[] = [
+      toBigInt(this.config.poolId.toString()), // pool id
+      toBigInt(this.config.collateral.address.toString()), // collateral
+      toBigInt(this.config.debt.address.toString()), // debt
+      toBigInt(this.config.vaultAllocator.toString()), // vault allocator
+    ];
+    const output = this.constructSimpleLeafData({
+      id: this.config.id,
+      target: this.VESU_MULTIPLY,
+      method: 'modify_lever',
+      packedArguments
+    }, SIMPLE_SANITIZER_V2);
+
+    return { leaf: output, callConstructor: this.getMultiplyCall.bind(this) };
+  }
+
+  getMultiplyCall = (params: VesuMultiplyCallParams): ManageCall => {
+    const isIncrease = params.isIncrease;
+    const multiplyParams = isIncrease ? params.increaseParams : params.decreaseParams;
+    if (!multiplyParams) {
+      throw new Error('Multiply params are not provided');
+    }
+    const multiplyContract = new Contract({abi: VesuMultiplyAbi, address: this.VESU_MULTIPLY.toString(), providerOrAccount: new RpcProvider({nodeUrl: ''})});
+    const call = multiplyContract.populate('modify_lever', {
+      modify_lever_params: getVesuMultiplyParams(isIncrease, {
+        ...multiplyParams,
+        user: this.config.vaultAllocator,
+        pool_id: this.config.poolId,
+        collateral_asset: this.config.collateral.address,
+        debt_asset: this.config.debt.address,
+        recipient: this.config.vaultAllocator
+      })
+    });
+    return {
+      sanitizer: SIMPLE_SANITIZER_V2,
+      call: {
+        contractAddress: this.VESU_MULTIPLY,
+        selector: hash.getSelectorFromName('modify_lever'),
+        calldata: [
+          ...call.calldata as bigint[]
+        ]
+      }
+    }
+  }
+
+  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,
+        method: 'modify_delegation',
+        packedArguments
+      }, SIMPLE_SANITIZER_V2);
+
+      return { leaf: output, callConstructor: this.getVesuModifyDelegationCall.bind(this) };
+    }
+  }
+
+  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', {
+      pool_id: this.config.poolId.toBigInt(),
+      delegatee: this.VESU_MULTIPLY.toBigInt(),
+      delegation: params.delegation,
+    });
+    return {
+      sanitizer: SIMPLE_SANITIZER_V2,
+      call: {
+        contractAddress: this.VESU_SINGLETON,
+        selector: hash.getSelectorFromName('modify_delegation'),
+        calldata: [
+          ...call.calldata as bigint[]
+        ]
+      }
+    }
+  }
   
   getDefispringRewardsAdapter = (id: string): () => AdapterLeafType<VesuDefiSpringRewardsCallParams> => {
     return () => {