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

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

@@ -1,9 +1,11 @@
-export * from "./baseAdapter";
-export * from "./common-adapter";
-export * from "./vesu-adapter";
-export * from "./vesu-supply-only-adapter";
-export * from "./vesu-multiply-adapter";
-export * from "./extended-adapter";
-export * from "./adapter-utils";
-export * from "./unused-balance-adapter";
-export * from "./avnu-adapter";
+export * from "./baseAdapter";
+export * from "./common-adapter";
+export * from "./vesu-adapter";
+export * from "./vesu-supply-only-adapter";
+export * from "./vesu-multiply-adapter";
+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 "./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);
+  }
+}

package/src/strategies/universal-adapters/token-transfer-adapter.ts

@@ -0,0 +1,200 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import {
+  APYType,
+  BaseAdapter,
+  BaseAdapterConfig,
+  DepositParams,
+  ManageCall,
+  PositionAmount,
+  PositionAPY,
+  PositionInfo,
+  SupportedPosition,
+  WithdrawParams,
+} from "./baseAdapter";
+import { hash, uint256 } from "starknet";
+import { ERC20, TokenMarketData } from "@/modules";
+import { Protocols } from "@/interfaces";
+import { SIMPLE_SANITIZER, toBigInt, TRANSFER_SANITIZER } from "./adapter-utils";
+import { logger } from "@/utils";
+
+export interface TokenTransferAdapterConfig extends BaseAdapterConfig {
+  /** Address that funds are sent FROM during deposit (and returned TO during withdraw) */
+  fromAddress: ContractAddr;
+  /** Address that funds are sent TO during deposit (and pulled FROM during withdraw) */
+  toAddress: ContractAddr;
+}
+
+/**
+ * Adapter for transferring a single token between two fixed addresses.
+ *
+ * Deposit: transfers baseToken from `fromAddress` → `toAddress`
+ * Withdraw: transfers baseToken from `toAddress` → `fromAddress` (requires toAddress to approve fromAddress/VA)
+ *
+ * Proof IDs are derived from `tr_<symbol>_<toAddrShort>` to be unique per token+destination pair.
+ */
+export class TokenTransferAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+  readonly config: TokenTransferAdapterConfig;
+  readonly tokenMarketData: TokenMarketData;
+
+  constructor(config: TokenTransferAdapterConfig) {
+    super(config, TokenTransferAdapter.name, Protocols.NONE);
+    this.config = config;
+    this.tokenMarketData = new TokenMarketData(this.config.pricer, this.config.networkConfig);
+  }
+
+  private _idBase(): string {
+    return `tr_${this.config.baseToken.symbol}_${this.config.toAddress.shortString()}`;
+  }
+
+  private _depositCallProofReadableId(): string {
+    return `${this._idBase()}`;
+  }
+
+  private _withdrawCallProofReadableId(): string {
+    return `tr_wd_${this.config.baseToken.symbol}_${this.config.toAddress.shortString()}`;
+  }
+
+  protected async getAPY(_supportedPosition: SupportedPosition): Promise<PositionAPY> {
+    const isSupported = this.tokenMarketData.isAPYSupported(this.config.baseToken);
+    const apy = isSupported ? await this.tokenMarketData.getAPY(this.config.baseToken) : 0;
+    return { apy, type: isSupported ? APYType.LST : APYType.BASE };
+  }
+
+  protected async getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount> {
+    // only measure balance of toAddress, bcz fromAddress usually gets trakced in unused balance or a previous token transfer adapter
+    try {
+      const balance = await new ERC20(this.config.networkConfig).balanceOf(
+        supportedPosition.asset.address,
+        this.config.toAddress.address,
+        supportedPosition.asset.decimals,
+      );
+      return { amount: balance, remarks: `Unused balance [${this.config.toAddress.shortString()}]` };
+    } catch (_e) {
+      logger.error(`${TokenTransferAdapter.name}::getPosition: failed for ${supportedPosition.asset.symbol}`);
+      throw new Error(`${TokenTransferAdapter.name}: failed to get balance for ${supportedPosition.asset.symbol}`);
+    }
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    const baseToken = this.config.baseToken;
+    const fromBalance = await new ERC20(this.config.networkConfig).balanceOf(
+      baseToken.address,
+      this.config.fromAddress.address,
+      baseToken.decimals,
+    );
+    const depositable = amount && amount.toNumber() <= fromBalance.toNumber() ? amount : fromBalance;
+    const usdValue = await this.getUSDValue(baseToken, depositable);
+    return {
+      tokenInfo: baseToken,
+      amount: depositable,
+      usdValue,
+      remarks: "Max deposit (from-address balance)",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol,
+    };
+  }
+
+  async maxWithdraw(): Promise<PositionInfo> {
+    const baseToken = this.config.baseToken;
+    const toBalance = await new ERC20(this.config.networkConfig).balanceOf(
+      baseToken.address,
+      this.config.toAddress.address,
+      baseToken.decimals,
+    );
+    const usdValue = await this.getUSDValue(baseToken, toBalance);
+    return {
+      tokenInfo: baseToken,
+      amount: toBalance,
+      usdValue,
+      remarks: "Max withdraw (to-address balance)",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol,
+    };
+  }
+
+  protected _getDepositLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    return [
+      {
+        target: this.config.baseToken.address,
+        method: "transfer",
+        packedArguments: [this.config.toAddress.toBigInt()],
+        sanitizer: TRANSFER_SANITIZER,
+        id: this._depositCallProofReadableId(),
+      },
+    ];
+  }
+
+  protected _getWithdrawLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    // note, to address should have given allowance to from address
+    return [
+      {
+        target: this.config.baseToken.address,
+        method: "transfer_from",
+        packedArguments: [
+          this.config.toAddress.toBigInt(),   // from
+          this.config.fromAddress.toBigInt(),  // to
+        ],
+        sanitizer: TRANSFER_SANITIZER,
+        id: this._withdrawCallProofReadableId(),
+      },
+    ];
+  }
+
+  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+    const amount = params.amount;
+    const uint256Amount = uint256.bnToUint256(amount.toWei());
+    return [
+      {
+        proofReadableId: this._depositCallProofReadableId(),
+        sanitizer: TRANSFER_SANITIZER,
+        call: {
+          contractAddress: this.config.baseToken.address,
+          selector: hash.getSelectorFromName("transfer"),
+          calldata: [
+            this.config.toAddress.toBigInt(),
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString()),
+          ],
+        },
+      },
+    ];
+  }
+
+  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+    const amount = params.amount;
+    const uint256Amount = uint256.bnToUint256(amount.toWei());
+    // note, from address should have given allowance to to address
+    return [
+      {
+        proofReadableId: this._withdrawCallProofReadableId(),
+        sanitizer: TRANSFER_SANITIZER,
+        call: {
+          contractAddress: this.config.baseToken.address,
+          selector: hash.getSelectorFromName("transfer_from"),
+          calldata: [
+            this.config.toAddress.toBigInt(),    // from
+            this.config.fromAddress.toBigInt(),   // to
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString()),
+          ],
+        },
+      },
+    ];
+  }
+
+  async getHealthFactor(): Promise<number> {
+    return Promise.resolve(10);
+  }
+}