@strkfarm/sdk 2.0.0-dev.5 → 2.0.0-dev.50

package/src/strategies/svk-strategy.ts

@@ -1,9 +1,9 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { IConfig, IStrategyMetadata, TokenInfo, VaultPosition } from "@/interfaces";
+import { IConfig, IStrategyMetadata, Protocols, 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 { BaseStrategy, SingleActionAmount, SingleTokenInfo, UserPositionCard, UserPositionCardsInput } from "./base-strategy";
+import { BlockIdentifier, Call, Contract, num, uint256 } from "starknet";
 import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
 import { UniversalStrategySettings } from "./universal-strategy";
 import { UNIVERSAL_MANAGE_IDS } from "./universal-strategy";
@@ -15,9 +15,9 @@ 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> 
+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 */
@@ -36,13 +36,13 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     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,
@@ -57,14 +57,81 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     return this.metadata.depositTokens[0];
   }
 
+  async depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]> {
+    // Technically its not erc4626 abi, but we just need approve call
+    // so, its ok to use it
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Deposit token mismatch"
+    );
+    const assetContract = new Contract({
+      abi: UniversalVaultAbi,
+      address: this.asset().address.address,
+      providerOrAccount: this.config.provider
+    });
+    const call1 = assetContract.populate("approve", [
+      this.address.address,
+      uint256.bnToUint256(amountInfo.amount.toWei())
+    ]);
+    const call2 = this.contract.populate("deposit", [
+      uint256.bnToUint256(amountInfo.amount.toWei()),
+      receiver.address
+    ]);
+    return [call1, call2];
+  }
+
+  async withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr, isMaxWithdraw: boolean = false): Promise<Call[]> {
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Withdraw token mismatch"
+    );
+    const shares = isMaxWithdraw
+      ? await this.contract.call("balanceOf", [receiver.address])
+      : await this.contract.call('convert_to_shares', [uint256.bnToUint256(amountInfo.amount.toWei())]);
+    const call = this.contract.populate("request_redeem", [
+      uint256.bnToUint256(shares.toString()),
+      receiver.address,
+      owner.address
+    ]);
+    return [call];
+  }
+
+  async getUserTVL(user: ContractAddr, blockIdentifier: BlockIdentifier = "latest"): Promise<SingleTokenInfo> {
+    const shares: any = await this.contract.call("balanceOf", [user.address], { blockIdentifier });
+    const assets: any = await this.contract.call(
+      "convert_to_assets",
+      [uint256.bnToUint256(shares)],
+      { blockIdentifier }
+    );
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+
+    const blockNumber = typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint"
+      ? Number(blockIdentifier)
+      : undefined;
+
+    const price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol,
+      blockNumber
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+
   /**
    * 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().address,
+      this.metadata.additionalInfo.vaultAllocator,
       this.asset().decimals
     );
     const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
@@ -76,6 +143,24 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     };
   }
 
+  /**
+    * Builds a manage call from an adapter's proof tree.
+    * DRY helper for the repeated getProofs → getManageCall pattern.
+    */
+  protected async buildManageCallFromAdapter(
+    adapter: { getProofs: (isDeposit: boolean, tree: any) => any },
+    isDeposit: boolean,
+    amount: Web3Number,
+    additionalParams?: Record<string, any>,
+  ): Promise<Call> {
+    const proofsInfo = adapter.getProofs(isDeposit, this.getMerkleTree());
+    const manageCalls = await proofsInfo.callConstructor({ amount, ...additionalParams });
+    return this.getManageCall(
+      this.getProofGroupsForManageCalls(manageCalls),
+      manageCalls,
+    );
+  }
+
   /**
    * Bridges liquidity from the vault allocator back to the vault.
    * Note: This function is common for any SVK strategy.
@@ -85,37 +170,54 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     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 });
-    
+    const manageCalls = [...approveCalls, ...bringLiquidityCalls];
+
     // Combine into final call
-    return this.getManageCall(proofGroups, [...approveCalls, ...bringLiquidityCalls]);
+    return this.getManageCall(this.getProofGroupsForManageCalls(manageCalls), manageCalls);
+  }
+
+  /**
+   * Resolves ordered merkle proofs from emitted manage calls.
+   * This ensures only runtime-required proofs are passed to manager calls.
+   */
+  protected getProofGroupsForManageCalls(manageCalls: ManageCall[]): string[][] {
+    const tree = this.getMerkleTree();
+    const proofByReadableId = new Map<string, string[]>();
+    for (const [i, v] of tree.entries()) {
+      if (proofByReadableId.has(v.readableId)) {
+        throw new Error(`Duplicate readableId found in merkle tree: ${v.readableId}`);
+      }
+      proofByReadableId.set(v.readableId, tree.getProof(i));
+    }
+
+    return manageCalls.map((manageCall, index) => {
+      if (!manageCall.proofReadableId) {
+        throw new Error(`Missing proofReadableId for manage call at index ${index}`);
+      }
+      const proof = proofByReadableId.get(manageCall.proofReadableId);
+      if (!proof) {
+        throw new Error(`Proof not found for readableId: ${manageCall.proofReadableId}`);
+      }
+      return proof;
+    });
   }
 
   /**
@@ -157,10 +259,10 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
    */
   getManageCall(proofGroups: string[][], manageCalls: ManageCall[]): Call {
     assert(
-      proofGroups.length == manageCalls.length, 
+      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),
@@ -176,7 +278,7 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
    */
   getSetManagerCall(strategist: ContractAddr, root = this.getMerkleRoot()): Call {
     return this.managerContract.populate('set_manage_root', [
-      strategist.address, 
+      strategist.address,
       num.getHexString(root)
     ]);
   }
@@ -194,7 +296,19 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
    */
   async getVaultPositions(): Promise<VaultPosition[]> {
     const positions = await Promise.all(
-      this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.getPositions())
+      [
+        ...this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.getPositions()),
+        (async () => {
+          const unused = await this.getUnusedBalance();
+          return {
+            amount: unused.amount,
+            usdValue: unused.usdValue,
+            remarks: "Unused Balance",
+            tokenInfo: this.asset(),
+            protocol: Protocols.NONE
+          };
+        })()
+      ]
     )
     return positions.flat().map((position) => ({
       amount: position.amount,
@@ -222,10 +336,151 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     const netAPY = weightedAPYs / totalHoldingsUSDValue;
     return {
       net: netAPY,
-      splits: allPositions.map(p => ({apy: p.apy.apy, id: p.remarks ?? ''}))
+      splits: allPositions.map(p => ({ apy: p.apy.apy, id: p.remarks ?? '' }))
     };
   }
 
+  async getTVL(): Promise<SingleTokenInfo> {
+    const tvl =  await this.contract.call('total_assets', []) as bigint;
+    const amount = Web3Number.fromWei(tvl.toString(), this.asset().decimals);
+    const price = await this.pricer.getPrice(this.asset().symbol);
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+
+  async getUserRealizedAPY(
+    blockIdentifier: BlockIdentifier = "latest",
+    sinceBlocks = 600000
+  ): Promise<number> {
+    logger.verbose(
+      `${this.getTag()}: getUserRealizedAPY => starting with blockIdentifier=${blockIdentifier}, sinceBlocks=${sinceBlocks}`
+    );
+
+    const blockNow =
+      typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint"
+        ? Number(blockIdentifier)
+        : (await this.config.provider.getBlockLatestAccepted()).block_number;
+    const blockNowTime =
+      typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint"
+        ? (await this.config.provider.getBlockWithTxs(blockIdentifier)).timestamp
+        : new Date().getTime() / 1000;
+
+    const blockBefore = Math.max(
+      blockNow - sinceBlocks,
+      this.metadata.launchBlock
+    );
+
+    const assetsNowRaw: bigint = await this.contract.call("total_assets", [], {
+      blockIdentifier,
+    }) as bigint;
+    const amountNow = Web3Number.fromWei(
+      assetsNowRaw.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+
+    const supplyNowRaw: bigint = await this.contract.call("total_supply", [], {
+      blockIdentifier,
+    }) as bigint;
+    const supplyNow = Web3Number.fromWei(supplyNowRaw.toString(), 18);
+
+    const assetsBeforeRaw: bigint = await this.contract.call(
+      "total_assets",
+      [],
+      { blockIdentifier: blockBefore }
+    ) as bigint;
+    const amountBefore = Web3Number.fromWei(
+      assetsBeforeRaw.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+
+    const supplyBeforeRaw: bigint = await this.contract.call(
+      "total_supply",
+      [],
+      { blockIdentifier: blockBefore }
+    ) as bigint;
+    const supplyBefore = Web3Number.fromWei(supplyBeforeRaw.toString(), 18);
+
+    const blockBeforeInfo = await this.config.provider.getBlockWithTxs(
+      blockBefore
+    );
+
+    const assetsPerShareNow = amountNow
+      .multipliedBy(1e18)
+      .dividedBy(supplyNow.toString());
+
+    const assetsPerShareBf = amountBefore
+      .multipliedBy(1e18)
+      .dividedBy(supplyBefore.toString());
+
+    const timeDiffSeconds = blockNowTime - blockBeforeInfo.timestamp;
+
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsNow: ${amountNow.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsBefore: ${amountBefore.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsPerShareNow: ${assetsPerShareNow.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsPerShareBf: ${assetsPerShareBf.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Supply before: ${supplyBefore.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Supply now: ${supplyNow.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Time diff in seconds: ${timeDiffSeconds}`);
+
+    const apyForGivenBlocks =
+      Number(
+        assetsPerShareNow
+          .minus(assetsPerShareBf)
+          .multipliedBy(10000)
+          .dividedBy(assetsPerShareBf)
+      ) / 10000;
+
+    return (apyForGivenBlocks * (365 * 24 * 3600)) / timeDiffSeconds;
+  }
+
+  async getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+    const { user, investmentFlows = [] } = input;
+    const [userTVL] = await Promise.all([
+      this.getUserTVL(user),
+    ]);
+    const cards: UserPositionCard[] = [
+      {
+        title: "Your Holdings",
+        tooltip: "Your Holdings",
+        value: this.formatTokenAmountForCard(userTVL.amount, userTVL.tokenInfo),
+        subValue: `≈ ${this.formatUSDForCard(userTVL.usdValue)}`,
+        subValueColor: "positive",
+      },
+    ];
+
+    let lifetimeAmount = userTVL.amount.multipliedBy(0);
+    let lifetimeTokenInfo = userTVL.tokenInfo;
+    let lifetimeUsdValue = 0;
+    if (investmentFlows.length > 0) {
+      try {
+        const earningsResult = this.getLifetimeEarnings(userTVL, investmentFlows);
+        lifetimeAmount = earningsResult.lifetimeEarnings;
+        lifetimeTokenInfo = earningsResult.tokenInfo.tokenInfo;
+        const userAmount = userTVL.amount.toNumber();
+        if (Number.isFinite(userAmount) && userAmount > 0) {
+          const pricePerToken = userTVL.usdValue / userAmount;
+          lifetimeUsdValue = lifetimeAmount.toNumber() * pricePerToken;
+        }
+      } catch (error) {
+        logger.warn(`${this.getTag()}::getUserPositionCards lifetime earnings fallback`, error);
+      }
+    }
+
+    cards.push({
+      title: "Lifetime Earnings",
+      tooltip: "Lifetime Earnings",
+      value: this.formatTokenAmountForCard(lifetimeAmount, lifetimeTokenInfo),
+      subValue: `≈ ${this.formatUSDForCard(lifetimeUsdValue)}`,
+      subValueColor: this.getSubValueColorFromSignedNumber(lifetimeUsdValue),
+    });
+
+    return cards;
+  }
+
   async getPrevAUM() {
     const currentAUM: bigint = await this.contract.call('aum', []) as bigint;
     const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
@@ -243,5 +498,11 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     return maxWithdrawables;
   }
 
-}
 
+  async getMaxTVL(): Promise<Web3Number> {
+    const lstToken = this.asset();
+    const depositLimit: any = await this.contract.call("get_deposit_limit", []);
+    const limitBN = uint256.uint256ToBN(depositLimit);
+    return Web3Number.fromWei(limitBN.toString(), lstToken.decimals);
+  }
+}