@strkfarm/sdk 1.1.70 → 2.0.0-dev.1

package/src/strategies/index.ts

@@ -5,4 +5,7 @@ export * from './base-strategy';
 export * from './sensei';
 export * from './universal-adapters';
 export * from './universal-strategy';
-export * from './universal-lst-muliplier-strategy';
+export * from './universal-lst-muliplier-strategy';
+export * from './vesu-extended-strategy/vesu-extended-strategy';
+export * from './vesu-extended-strategy/utils/config.runtime';
+export * from './vesu-extended-strategy/utils/helper';

package/src/strategies/svk-strategy.ts

@@ -0,0 +1,247 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { IConfig, IStrategyMetadata, TokenInfo, VaultPosition } from "@/interfaces";
+import { PricerBase } from "@/modules/pricerBase";
+import { ERC20 } from "@/modules";
+import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { Call, Contract, num } from "starknet";
+import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
+import { UniversalStrategySettings } from "./universal-strategy";
+import { UNIVERSAL_MANAGE_IDS } from "./universal-strategy";
+import UniversalVaultAbi from '../data/universal-vault.abi.json';
+import ManagerAbi from '../data/vault-manager.abi.json';
+import { ManageCall, PositionInfo } from "./universal-adapters";
+
+/**
+ * Base class for all SVK (Starknet Vault Kit) strategies.
+ * Contains common functions that are shared across all SVK strategies.
+ */
+export abstract class SVKStrategy<S extends UniversalStrategySettings> 
+  extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
+  
+  /** Contract address of the strategy */
+  readonly address: ContractAddr;
+  /** Pricer instance for token price calculations */
+  readonly pricer: PricerBase;
+  /** Metadata containing strategy information */
+  readonly metadata: IStrategyMetadata<S>;
+  /** Contract instance for interacting with the strategy */
+  readonly contract: Contract;
+  /** Manager contract instance for merkle verification */
+  readonly managerContract: Contract;
+  /** Cached merkle tree instance */
+  merkleTree: StandardMerkleTree | undefined;
+
+  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>) {
+    super(config);
+    this.pricer = pricer;
+    this.metadata = metadata;
+    this.address = metadata.address;
+    
+    this.contract = new Contract({
+      abi: UniversalVaultAbi,
+      address: this.address.address,
+      providerOrAccount: this.config.provider
+    });
+    
+    this.managerContract = new Contract({
+      abi: ManagerAbi,
+      address: this.metadata.additionalInfo.manager.address,
+      providerOrAccount: this.config.provider
+    });
+  }
+
+  /**
+   * Returns the asset token for this strategy
+   */
+  asset(): TokenInfo {
+    return this.metadata.depositTokens[0];
+  }
+
+  /**
+   * Returns the unused balance in the vault allocator.
+   * Note: This function is common for any SVK strategy.
+   */
+  async getUnusedBalance(): Promise<SingleTokenInfo> {
+    const balance = await (new ERC20(this.config)).balanceOf(
+      this.asset().address, 
+      this.metadata.additionalInfo.vaultAllocator, 
+      this.asset().decimals
+    );
+    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const usdValue = Number(balance.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount: balance,
+      usdValue
+    };
+  }
+
+  /**
+   * Bridges liquidity from the vault allocator back to the vault.
+   * Note: This function is common for any SVK strategy.
+   */
+  async getBringLiquidityCall(params: { amount: Web3Number }): Promise<Call> {
+    // Find approve leaf adapter
+    const approveAdapter = this.metadata.additionalInfo.leafAdapters.find(
+      adapter => adapter().leaves.find(leaf => leaf.readableId === UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY)
+    );
+    
+    if (!approveAdapter) {
+      throw new Error(`${this.getTag()}::getBringLiquidityCall: approve adapter not found`);
+    }
+    
+    // Find bring liquidity leaf adapter
+    const bringLiquidityAdapter = this.metadata.additionalInfo.leafAdapters.find(
+      adapter => adapter().leaves.find(leaf => leaf.readableId === UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY)
+    );
+    
+    if (!bringLiquidityAdapter) {
+      throw new Error(`${this.getTag()}::getBringLiquidityCall: bring liquidity adapter not found`);
+    }
+    
+    // Get proofs
+    const tree = this.getMerkleTree();
+    const proofGroups: string[][] = [];
+    for (const [i, v] of tree.entries()) {
+      if (v.readableId === UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY ||
+          v.readableId === UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY) {
+        proofGroups.push(tree.getProof(i));
+      }
+    }
+    
+    // Construct calls
+    logger.verbose("approve adapter amount", params.amount);
+    const approveCalls = await approveAdapter().callConstructor({ amount: params.amount });
+    const bringLiquidityCalls = await bringLiquidityAdapter().callConstructor({ amount: params.amount });
+    
+    // Combine into final call
+    return this.getManageCall(proofGroups, [...approveCalls, ...bringLiquidityCalls]);
+  }
+
+  /**
+   * Gets all leaves from all leaf adapters.
+   * Note: This function is common for any SVK strategy.
+   */
+  getAllLeaves(): LeafData[] {
+    const leaves = this.metadata.additionalInfo.leafAdapters.map(adapter => adapter());
+    const _leaves: LeafData[] = [];
+    leaves.forEach((_l) => {
+      _leaves.push(..._l.leaves);
+    });
+    return _leaves;
+  }
+
+  /**
+   * Builds and caches the merkle tree from all leaf adapters.
+   * Note: This function is common for any SVK strategy.
+   */
+  getMerkleTree(): StandardMerkleTree {
+    if (this.merkleTree) return this.merkleTree;
+    const _leaves = this.getAllLeaves();
+    const standardTree = StandardMerkleTree.of(_leaves);
+    this.merkleTree = standardTree;
+    return standardTree;
+  }
+
+  /**
+   * Gets the merkle root of the tree.
+   * Note: This function is common for any SVK strategy.
+   */
+  getMerkleRoot(): string {
+    return this.getMerkleTree().root;
+  }
+
+  /**
+   * Combines proofs and manage calls into a single Starknet call.
+   * Note: This function is common for any SVK strategy.
+   */
+  getManageCall(proofGroups: string[][], manageCalls: ManageCall[]): Call {
+    assert(
+      proofGroups.length == manageCalls.length, 
+      `Proof IDs and Manage Calls length mismatch: ${proofGroups.length} != ${manageCalls.length}`
+    );
+    
+    return this.managerContract.populate('manage_vault_with_merkle_verification', {
+      proofs: proofGroups.map(group => group),
+      decoder_and_sanitizers: manageCalls.map(call => call.sanitizer.address),
+      targets: manageCalls.map(call => call.call.contractAddress.address),
+      selectors: manageCalls.map(call => call.call.selector),
+      calldatas: manageCalls.map(call => call.call.calldata),
+    });
+  }
+
+  /**
+   * Creates a call to set the merkle root on the manager contract.
+   * Note: This function is common for any SVK strategy.
+   */
+  getSetManagerCall(strategist: ContractAddr, root = this.getMerkleRoot()): Call {
+    return this.managerContract.populate('set_manage_root', [
+      strategist.address, 
+      num.getHexString(root)
+    ]);
+  }
+
+  /**
+   * Returns a tag for logging purposes.
+   * Should be overridden by subclasses to provide strategy-specific tags.
+   */
+  abstract getTag(): string;
+
+
+  /**
+   * Returns the positions in the vault.
+   * @returns An array of VaultPosition objects representing the positions in the vault.
+   */
+  async getVaultPositions(): Promise<VaultPosition[]> {
+    const positions = await Promise.all(
+      this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.getPositions())
+    )
+    return positions.flat().map((position) => ({
+      amount: position.amount,
+      usdValue: position.usdValue,
+      remarks: position.remarks ?? '',
+      token: position.tokenInfo,
+      protocol: position.protocol
+    }))
+  }
+
+  async getHealthFactors(): Promise<number[]> {
+    return Promise.all(this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.getHealthFactor()));
+  }
+
+  // todo undo this
+  async netAPY(): Promise<{ net: number; splits: { apy: number; id: string; }[]; }> {
+    const allPositions: PositionInfo[] = [];
+    for (let adapter of this.metadata.additionalInfo.adapters) {
+      const positions = await adapter.adapter.getPositions();
+      allPositions.push(...positions);
+    }
+
+    const totalHoldingsUSDValue = allPositions.reduce((acc, curr) => acc + curr.usdValue, 0);
+    let weightedAPYs = allPositions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0);
+    const netAPY = weightedAPYs / totalHoldingsUSDValue;
+    return {
+      net: netAPY,
+      splits: allPositions.map(p => ({apy: p.apy.apy, id: p.remarks ?? ''}))
+    };
+  }
+
+  async getPrevAUM() {
+    const currentAUM: bigint = await this.contract.call('aum', []) as bigint;
+    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
+    logger.verbose(`${this.getTag()} Prev AUM: ${prevAum}`);
+    return prevAum;
+  }
+
+  async maxDepositables() {
+    const maxDepositables = await Promise.all(this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.maxDeposit()));
+    return maxDepositables;
+  }
+
+  async maxWithdrawables() {
+    const maxWithdrawables = await Promise.all(this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.maxWithdraw()));
+    return maxWithdrawables;
+  }
+
+}
+

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

@@ -0,0 +1,65 @@
+import { logger } from "@/utils";
+import { BaseAdapter, DepositParams, WithdrawParams } from "./baseAdapter";
+import { Web3Number } from "@/dataTypes";
+
+export class AdapterOptimizer {
+
+  // write a export function to compute the adapter to use 
+  // for a given withdraw/deposit action. It can be one or more adapters.
+  // Key decision factors:
+  // 1. The netAPY of the adapter is low compared to others (exhaust this first before using others)
+  // 2. Prefer one adapter over multiple adapters
+  static async getAdapterToUse(adapters: BaseAdapter<DepositParams, WithdrawParams>[], isDeposit: boolean, amount: Web3Number): Promise<BaseAdapter<DepositParams, WithdrawParams>[]> {
+    logger.verbose(`${this.name}::getAdapterToUse: adapters: ${JSON.stringify(adapters)}, isDeposit: ${isDeposit}, amount: ${amount.toFixed(9)}`);
+    const netAPYs = await Promise.all(adapters.map(a => a.getNetAPY()));
+    const indexAndNetAPYsArr = netAPYs.map((apy, index) => [index, apy]);
+    logger.verbose(`${this.name}::getAdapterToUse: netAPYs: ${JSON.stringify(netAPYs)}`);
+    // if is deposit
+    if (isDeposit) {
+      // sort apys by descending
+      const sortedNetAPYs = indexAndNetAPYsArr.sort((a, b) => (b[1] || 0) - (a[1] || 0));
+      logger.verbose(`${this.name}::getAdapterToUse: sortedNetAPYs: ${JSON.stringify(sortedNetAPYs)}`);
+
+      // get max depositables 
+      const adaptersToUse: BaseAdapter<DepositParams, WithdrawParams>[] = [];
+      let remainingAmount = amount;
+      for (const [index, _] of sortedNetAPYs) {
+        const adapter = adapters[index];
+        const maxDepositable = await adapter.maxDeposit(amount);
+        if (maxDepositable.amount.gt(0)) {
+          adaptersToUse.push(adapter);
+          remainingAmount = remainingAmount.minus(maxDepositable.amount).minimum(0);
+        }
+
+        if (remainingAmount.lte(0)) {
+          break;
+        }
+      }
+
+      return adaptersToUse;
+    } else {
+      // sort apys by ascending
+      const sortedNetAPYs = indexAndNetAPYsArr.sort((a, b) => (a[1] || 0) - (b[1] || 0));
+      logger.verbose(`${this.name}::getAdapterToUse: sortedNetAPYs: ${JSON.stringify(sortedNetAPYs)}`);
+
+      // get max withdrawables
+      const adaptersToUse: BaseAdapter<DepositParams, WithdrawParams>[] = [];
+      let remainingAmount = amount.abs();
+      for (const [index, _] of sortedNetAPYs) {
+        const adapter = adapters[index];
+        const maxWithdrawable = await adapter.maxWithdraw();
+        logger.verbose(`${this.name}::getAdapterToUse: maxWithdrawable: ${JSON.stringify(maxWithdrawable)}, adapter: ${adapter.name}, remainingAmount: ${remainingAmount}`);
+        if (maxWithdrawable.amount.gt(0)) {
+          adaptersToUse.push(adapter);
+          remainingAmount = remainingAmount.minus(maxWithdrawable.amount).minimum(0);
+        }
+
+        if (remainingAmount.lte(0)) {
+          break;
+        }
+      }
+
+      return adaptersToUse;
+    }
+  }
+}

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

@@ -2,6 +2,8 @@ import { ContractAddr } from "@/dataTypes";
 
 // Zellic audited
 export const SIMPLE_SANITIZER = ContractAddr.from('0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4');
+export const EXTENDED_SANITIZER = ContractAddr.from('0x65891708362b24dcf4c40c8e218cce6e82d1d6b3a3404c9ab00a48f08e2c110');
+export const AVNU_LEGACY_SANITIZER = ContractAddr.from('0x0656fBE853f116DD53956176a553eDe8fE65632252f8aceB50C1B9B6c8237309');
 // Without flashloan options
 export const SIMPLE_SANITIZER_V2 = ContractAddr.from('0x7b6f98311af8aa425278570e62abf523e6462eaa01a38c1feab9b2f416492e2');
 export const VESU_V2_MODIFY_POSITION_SANITIZER = ContractAddr.from('0x04Bf71F2BD9D6F8819057c9dD524F0d5fbc38317C00500d7b9a0FdCf01195066');
@@ -9,7 +11,9 @@ export const SIMPLE_SANITIZER_VESU_V1_DELEGATIONS = ContractAddr.from('0x5643d54
 export const PRICE_ROUTER = ContractAddr.from('0x05e83Fa38D791d2dba8E6f487758A9687FfEe191A6Cf8a6c5761ab0a110DB837');
 export const AVNU_MIDDLEWARE = ContractAddr.from('0x4a7972ed3f5d1e74a6d6c4a8f467666953d081c8f2270390cc169d50d17cb0d');
 export const AVNU_EXCHANGE = ContractAddr.from('0x04270219d365d6b017231b52e92b3fb5d7c8378b05e9abc97724537a80e93b0f');
-
+export const AVNU_EXCHANGE_FOR_LEGACY_USDC = ContractAddr.from('0x7bffc7f6bda62b7bee9b7880579633a38f7ef910e0ad5e686b0b8712e216a19')
+export const AVNU_QUOTE_URL = "https://starknet.api.avnu.fi/swap/v3/quotes";
+export const EXTENDED_CONTRACT = ContractAddr.from('0x062da0780fae50d68cecaa5a051606dc21217ba290969b302db4dd99d2e9b470');
 export const VESU_SINGLETON = ContractAddr.from('0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160');
 export function toBigInt(value: string | number): bigint {
     if (typeof value === 'string') {