@strkfarm/sdk 2.0.0-dev.28 → 2.0.0-dev.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "2.0.0-dev.28",
+  "version": "2.0.0-dev.29",
   "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",

package/src/dataTypes/bignumber.browser.ts

@@ -1,3 +1,4 @@
+import BigNumber from "bignumber.js";
 import { _Web3Number } from "./_bignumber";
 
 export class Web3Number extends _Web3Number<Web3Number> {
@@ -5,4 +6,8 @@ export class Web3Number extends _Web3Number<Web3Number> {
         const bn = (new Web3Number(weiNumber, decimals)).dividedBy(10 ** decimals)
         return new Web3Number(bn.toString(), decimals);
     }
-}
+
+    static fromNumber(number: number, decimals: number) {
+        return new Web3Number(number.toString(), decimals);
+    }
+}

package/src/dataTypes/bignumber.node.ts

@@ -8,6 +8,10 @@ export class Web3Number extends _Web3Number<Web3Number> {
         return new Web3Number(bn.toString(), decimals);
     }
 
+    static fromNumber(number: number, decimals: number) {
+        return new Web3Number(number.toString(), decimals);
+    }
+
     [util.inspect.custom](depth: any, opts: any): string {
         return this.toString();
     }
@@ -19,4 +23,4 @@ export class Web3Number extends _Web3Number<Web3Number> {
     inspect(depth: any, opts: any) {
         return this.toString();
     }
-}
+}

package/src/interfaces/common.tsx

@@ -414,6 +414,12 @@ const VaultProtocol: IProtocol = {
   name: "Vault",
   logo: ""
 }
+
+const TrovesProtocol: IProtocol = {
+  name: "Troves",
+  logo: "https://app.troves.fi/favicon.ico"
+};
+
 export const Protocols = {
   NONE: NoneProtocol,
   VESU: VesuProtocol,
@@ -421,5 +427,6 @@ export const Protocols = {
   EXTENDED: ExtendedProtocol,
   EKUBO: EkuboProtocol,
   AVNU: AvnuProtocol,
-  VAULT: VaultProtocol
+  VAULT: VaultProtocol,
+  TROVES: TrovesProtocol
 }

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

@@ -17,7 +17,7 @@ export interface ManageCall {
 }
 
 export interface SwapPriceInfo {
-  source: 'avnu' | 'ekubo';
+  source: 'avnu' | 'ekubo'; //  | 'no-swap';
   fromTokenSymbol: string;
   toTokenSymbol: string;
   fromAmount: number;

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

@@ -56,7 +56,7 @@ export class ExtendedAdapter extends BaseAdapter<
 > {
   readonly config: ExtendedAdapterConfig;
   readonly client: ExtendedWrapper;
-  readonly usdceToken: TokenInfo;
+  readonly usdcToken: TokenInfo;
   readonly retryDelayForOrderStatus: number;
   readonly minimumExtendedMovementAmount: number;
 
@@ -75,15 +75,15 @@ export class ExtendedAdapter extends BaseAdapter<
     this.client = client;
     this.retryDelayForOrderStatus =
       this.config.retryDelayForOrderStatus ?? 3000;
-    this.usdceToken = this.config.supportedPositions[0].asset;
+    this.usdcToken = this.config.supportedPositions[0].asset;
   }
 
   private _depositApproveProofReadableId(): string {
-    return `extended_approve_${this.usdceToken.symbol}`;
+    return `extended_approve_${this.usdcToken.symbol}`;
   }
 
   private _depositCallProofReadableId(): string {
-    return `extended_deposit_${this.usdceToken.symbol}`;
+    return `extended_deposit_${this.usdcToken.symbol}`;
   }
   //abstract means the method has no implementation in this class; instead, child classes must implement it.
   protected async getAPY(
@@ -173,7 +173,7 @@ export class ExtendedAdapter extends BaseAdapter<
   }[] {
     return [
       {
-        target: this.usdceToken.address,
+        target: this.usdcToken.address,
         method: "approve",
         packedArguments: [this.config.extendedContract.toBigInt()],
         id: this._depositApproveProofReadableId(),
@@ -204,14 +204,14 @@ export class ExtendedAdapter extends BaseAdapter<
 
   async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
     try {
-      const salt = Math.floor(Math.random() * 10 ** this.usdceToken.decimals);
+      const salt = Math.floor(Math.random() * 10 ** this.usdcToken.decimals);
       const amount = uint256.bnToUint256(params.amount.toWei());
       return [
         {
           proofReadableId: this._depositApproveProofReadableId(),
           sanitizer: SIMPLE_SANITIZER,
           call: {
-            contractAddress: this.usdceToken.address,
+            contractAddress: this.usdcToken.address,
             selector: hash.getSelectorFromName("approve"),
             calldata: [
               this.config.extendedContract.toBigInt(),

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

@@ -7,4 +7,5 @@ export * from "./vesu-modify-position-adapter";
 export * from "./extended-adapter";
 export * from "./adapter-utils";
 export * from "./token-transfer-adapter";
-export * from "./avnu-adapter";
+export * from "./avnu-adapter";
+export * from "./svk-troves-adapter";

package/src/strategies/universal-adapters/svk-troves-adapter.ts

@@ -0,0 +1,364 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { Protocols } from "@/interfaces";
+import {
+  BaseAdapter,
+  BaseAdapterConfig,
+  SupportedPosition,
+  PositionInfo,
+  PositionAPY,
+  APYType,
+  ManageCall,
+  AdapterLeafType,
+  GenerateCallFn,
+  DepositParams,
+  WithdrawParams,
+  PositionAmount,
+} from "./baseAdapter";
+import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import { hash, uint256, Contract } from "starknet";
+import { logger } from "@/utils";
+// Troves SVK universal vault ABI: ERC-4626 + SVK views (e.g. due_assets_from_owner).
+import universalVaultAbi from "@/data/universal-vault.abi.json";
+
+/** Public Troves strategies feed (APY + metadata). Override in config for tests. */
+export const DEFAULT_TROVES_STRATEGIES_API = "https://app.troves.fi/api/strategies";
+
+export interface SvkTrovesAdapterConfig extends BaseAdapterConfig {
+  /**
+   * On-chain Troves / SVK strategy vault: ERC-4626-style `deposit` / `withdraw` on the underlying asset,
+   * plus `due_assets_from_owner` for redemption NFT value still owed to an owner.
+   */
+  strategyVault: ContractAddr;
+  /**
+   * Troves API `strategies[].id` string (e.g. `hyper_xstrk`). Used to resolve APY from the public JSON feed.
+   */
+  trovesStrategyId: string;
+  /**
+   * Address whose vault **share** balance and **pending** redemption assets are measured.
+   * Defaults to `vaultAllocator` when omitted (typical STRKFarm vault wiring).
+   */
+  positionOwner?: ContractAddr;
+  /** Optional APY endpoint (defaults to {@link DEFAULT_TROVES_STRATEGIES_API}). */
+  trovesStrategiesApiUrl?: string;
+}
+
+type TrovesStrategiesApiPayload = {
+  strategies?: Array<{
+    id: string;
+    apy?: number | string;
+  }>;
+};
+
+function parseTrovesApyField(raw: unknown): number {
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw;
+  }
+  if (typeof raw === "string") {
+    const n = Number.parseFloat(raw);
+    if (Number.isFinite(n)) {
+      return n;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Universal adapter for **Starknet Vault Kit (SVK)** style Troves strategies:
+ * approve underlying → `deposit(assets, receiver)`, and `withdraw(assets, receiver, owner)` on the strategy vault.
+ *
+ * **Position sizing** (underlying asset, same decimals as `baseToken`):
+ * - Liquid: `convert_to_assets(balance_of(positionOwner))` on the strategy vault (vault shares).
+ * - Pending redemptions: `due_assets_from_owner(positionOwner)` on the same vault (NFT / queue claims not yet settled).
+ *
+ * **APY**: Fetched from Troves public API by `trovesStrategyId` (numeric `apy` field; non-numeric marketing values fall back to `0`).
+ */
+export class SvkTrovesAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+  readonly config: SvkTrovesAdapterConfig;
+
+  constructor(config: SvkTrovesAdapterConfig) {
+    super(config, SvkTrovesAdapter.name, Protocols.TROVES);
+    this.config = config;
+  }
+
+  /** Owner used for share balance + `due_assets_from_owner`. */
+  private _positionOwner(): ContractAddr {
+    return this.config.positionOwner ?? this.config.vaultAllocator;
+  }
+
+  /**
+   * Proof readable IDs must stay ≤ 31 chars (Cairo short string). We derive a short ASCII suffix from
+   * `strategyVault` address so multiple SVK adapters in one tree stay distinct.
+   */
+  private _proofSuffix(): string {
+    return this.config.strategyVault.address.replace(/^0x/, "").slice(-6);
+  }
+
+  private _depositApproveProofReadableId(): string {
+    return `appr_dep_svk_${this._proofSuffix()}`;
+  }
+
+  private _depositCallProofReadableId(): string {
+    return `dep_svk_${this._proofSuffix()}`;
+  }
+
+  private _withdrawCallProofReadableId(): string {
+    return `wtdrw_svk_${this._proofSuffix()}`;
+  }
+
+  protected async getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY> {
+    const CACHE_KEY = `svk_apy_${this.config.trovesStrategyId}`;
+    const cached = this.getCache<PositionAPY>(CACHE_KEY);
+    if (cached) {
+      return cached;
+    }
+
+    const url = this.config.trovesStrategiesApiUrl ?? DEFAULT_TROVES_STRATEGIES_API;
+
+    try {
+      const res = await fetch(url);
+      if (!res.ok) {
+        logger.warn(`${SvkTrovesAdapter.name}::getAPY: HTTP ${res.status} from ${url}`);
+        const fallback = { apy: 0, type: APYType.BASE };
+        this.setCache(CACHE_KEY, fallback, 300_000);
+        return fallback;
+      }
+      const body = (await res.json()) as TrovesStrategiesApiPayload;
+      const row = body.strategies?.find((s) => s.id === this.config.trovesStrategyId);
+      if (!row) {
+        logger.warn(
+          `${SvkTrovesAdapter.name}::getAPY: strategy id not found: ${this.config.trovesStrategyId}`,
+        );
+        const fallback = { apy: 0, type: APYType.BASE };
+        this.setCache(CACHE_KEY, fallback, 300_000);
+        return fallback;
+      }
+      const apy = parseTrovesApyField(row.apy);
+      const result: PositionAPY = { apy, type: APYType.BASE };
+      this.setCache(CACHE_KEY, result, 300_000);
+      return result;
+    } catch (error) {
+      logger.error(`${SvkTrovesAdapter.name}::getAPY:`, error);
+      throw error;
+    }
+  }
+
+  protected async getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null> {
+    const CACHE_KEY = `svk_pos_${this.config.strategyVault.address}_${this._positionOwner().address}`;
+    const cached = this.getCache<PositionAmount>(CACHE_KEY);
+    if (cached) {
+      return cached;
+    }
+
+    try {
+      const vault = new Contract({
+        abi: universalVaultAbi as never,
+        address: this.config.strategyVault.address,
+        providerOrAccount: this.config.networkConfig.provider,
+      });
+
+      const owner = this._positionOwner();
+      const decimals = supportedPosition.asset.decimals;
+      const shares = await vault.balance_of(owner.address);
+      const shareU256 = uint256.bnToUint256(shares);
+      const liquidAssetsRaw: any = await vault.convert_to_assets(shareU256);
+      const liquid = Web3Number.fromWei(liquidAssetsRaw.toString(), decimals);
+
+      let pending = Web3Number.fromWei("0", decimals);
+      try {
+        const dueRaw: any = await vault.call("due_assets_from_owner", [owner.address]);
+        pending = Web3Number.fromWei(dueRaw.toString(), decimals);
+      } catch (e) {
+        logger.warn(
+          `${SvkTrovesAdapter.name}::getPosition: due_assets_from_owner failed (treating as 0): ${(e as Error).message}`,
+        );
+      }
+
+      const total = liquid.plus(pending);
+      const remarks = `Troves ${this.config.trovesStrategyId} holdings`
+
+      const result: PositionAmount = {
+        amount: total,
+        remarks,
+      };
+
+      this.setCache(CACHE_KEY, result, 60_000);
+      return result;
+    } catch (error) {
+      logger.error(`${SvkTrovesAdapter.name}::getPosition:`, error);
+      throw error;
+    }
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    const baseToken = this.config.baseToken;
+    if (!amount) {
+      return {
+        tokenInfo: baseToken,
+        amount: new Web3Number("999999999999999999999999999", baseToken.decimals),
+        usdValue: 999999999999999999999999999,
+        remarks: "Max deposit (unbounded placeholder)",
+        apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+        protocol: this.protocol,
+      };
+    }
+    const usdValue = await this.getUSDValue(baseToken, amount);
+    return {
+      tokenInfo: baseToken,
+      amount,
+      usdValue,
+      remarks: "Deposit amount",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol,
+    };
+  }
+
+  async maxWithdraw(): Promise<PositionInfo> {
+    const baseToken = this.config.baseToken;
+    const current = await this.getPosition({ asset: baseToken, isDebt: false });
+    const pos = current ?? { amount: new Web3Number("0", baseToken.decimals), remarks: "" };
+    const usdValue = await this.getUSDValue(baseToken, pos.amount);
+    return {
+      tokenInfo: baseToken,
+      amount: pos.amount,
+      usdValue,
+      remarks: "Max withdraw (liquid + pending redemption, underlying units)",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol,
+    };
+  }
+
+  protected _getDepositLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const baseToken = this.config.baseToken;
+    const strategyVault = this.config.strategyVault;
+    const receiver = this.config.vaultAllocator;
+
+    return [
+      {
+        target: baseToken.address,
+        method: "approve",
+        packedArguments: [strategyVault.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._depositApproveProofReadableId(),
+      },
+      {
+        target: strategyVault,
+        method: "deposit",
+        packedArguments: [receiver.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._depositCallProofReadableId(),
+      },
+    ];
+  }
+
+  protected _getWithdrawLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const strategyVault = this.config.strategyVault;
+    const recv = this.config.vaultAllocator;
+    const owner = this.config.vaultAllocator;
+
+    return [
+      {
+        target: strategyVault,
+        method: "withdraw",
+        packedArguments: [recv.toBigInt(), owner.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._withdrawCallProofReadableId(),
+      },
+    ];
+  }
+
+  getDepositAdapter(): AdapterLeafType<DepositParams> {
+    const leafConfigs = this._getDepositLeaf();
+    const leaves = leafConfigs.map((config) => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      return this.constructSimpleLeafData({ id, target, method, packedArguments }, sanitizer);
+    });
+    return { leaves, callConstructor: this.getDepositCall.bind(this) as unknown as GenerateCallFn<DepositParams> };
+  }
+
+  getWithdrawAdapter(): AdapterLeafType<WithdrawParams> {
+    const leafConfigs = this._getWithdrawLeaf();
+    const leaves = leafConfigs.map((config) => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      return this.constructSimpleLeafData({ id, target, method, packedArguments }, sanitizer);
+    });
+    return { leaves, callConstructor: this.getWithdrawCall.bind(this) as unknown as GenerateCallFn<WithdrawParams> };
+  }
+
+  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+    const baseToken = this.config.baseToken;
+    const strategyVault = this.config.strategyVault;
+    const amount = params.amount;
+    const uint256Amount = uint256.bnToUint256(amount.toWei());
+    const receiver = this.config.vaultAllocator;
+
+    return [
+      {
+        proofReadableId: this._depositApproveProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: baseToken.address,
+          selector: hash.getSelectorFromName("approve"),
+          calldata: [
+            strategyVault.toBigInt(),
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString()),
+          ],
+        },
+      },
+      {
+        proofReadableId: this._depositCallProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: strategyVault,
+          selector: hash.getSelectorFromName("deposit"),
+          calldata: [
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString()),
+            receiver.toBigInt(),
+          ],
+        },
+      },
+    ];
+  }
+
+  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+    const strategyVault = this.config.strategyVault;
+    const amount = params.amount;
+    const uint256Amount = uint256.bnToUint256(amount.toWei());
+    const recv = this.config.vaultAllocator;
+    const owner = this.config.vaultAllocator;
+
+    return [
+      {
+        proofReadableId: this._withdrawCallProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: strategyVault,
+          selector: hash.getSelectorFromName("withdraw"),
+          calldata: [
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString()),
+            recv.toBigInt(),
+            owner.toBigInt(),
+          ],
+        },
+      },
+    ];
+  }
+
+  getHealthFactor(): Promise<number> {
+    return Promise.resolve(10);
+  }
+}