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

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

@@ -0,0 +1,511 @@
+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, SVK_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";
+import redeemRequestNftAbi from "@/data/redeem-request-nft.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;
+  /**
+   * Optional redeem request NFT contract address. When provided, pending assets are calculated
+   * using `getPendingAssetsFromOwnerNFTMethod` instead of `due_assets_from_owner`.
+   */
+  redeemRequestNFT?: ContractAddr;
+}
+
+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);
+      if (this.config.redeemRequestNFT) {
+        pending = await this.getPendingAssetsFromOwnerNFTMethod(
+          this.config.redeemRequestNFT,
+          owner,
+          decimals,
+        );
+      } else {
+        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 getPendingAssetsFromOwner(
+    owner: ContractAddr = this._positionOwner(),
+    decimals: number = this.config.baseToken.decimals,
+  ): Promise<Web3Number> {
+    const vault = new Contract({
+      abi: universalVaultAbi as never,
+      address: this.config.strategyVault.address,
+      providerOrAccount: this.config.networkConfig.provider,
+    });
+
+    try {
+      const dueRaw: any = await vault.call("due_assets_from_owner", [owner.address]);
+      return Web3Number.fromWei(dueRaw.toString(), decimals);
+    } catch (e) {
+      logger.warn(
+        `${SvkTrovesAdapter.name}::getPendingAssetsFromOwner: due_assets_from_owner failed (treating as 0): ${(e as Error).message}`,
+      );
+      return Web3Number.fromWei("0", decimals);
+    }
+  }
+
+  /**
+   * Get pending assets from owner by scanning redeem request NFTs.
+   * This method iterates backwards through NFT IDs to find all pending redemptions for a specific owner.
+   *
+   * @param redeemRequestNFT - The redeem request NFT contract address
+   * @param owner - The owner address to check for pending redemptions (defaults to positionOwner)
+   * @param decimals - Token decimals for conversion (defaults to baseToken decimals)
+   * @returns Total pending assets from all NFTs owned by the specified address
+   */
+  async getPendingAssetsFromOwnerNFTMethod(
+    redeemRequestNFT: ContractAddr,
+    owner: ContractAddr = this._positionOwner(),
+    decimals: number = this.config.baseToken.decimals,
+  ): Promise<Web3Number> {
+    try {
+      const nftContract = new Contract({
+        abi: redeemRequestNftAbi as never,
+        address: redeemRequestNFT.address,
+        providerOrAccount: this.config.networkConfig.provider,
+      });
+
+      // Step 1: Get the latest NFT ID (the one that is not yet used)
+      const idLenRaw: any = await nftContract.id_len();
+      const latestId = BigInt(idLenRaw.toString());
+
+      if (latestId === 0n) {
+        logger.info(
+          `${SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: No NFTs minted yet`,
+        );
+        return Web3Number.fromWei("0", decimals);
+      }
+
+      // Step 2: Start from (latestId - 1) and loop backwards to find all pending NFTs
+      const matchingIds: bigint[] = [];
+      let currentId = latestId - 1n;
+
+      while (currentId >= 0n) {
+        try {
+          // Convert currentId to u256 format
+          const idU256 = uint256.bnToUint256(currentId);
+          const ownerRaw: any = await nftContract.owner_of(idU256);
+
+          // Step 3: Filter IDs that have the owner matching our parameter
+          // Use ContractAddr.from to normalize addresses before comparison
+          const nftOwnerAddr = ContractAddr.from(ownerRaw.toString());
+          if (nftOwnerAddr.eq(owner)) {
+            matchingIds.push(currentId);
+            logger.debug(
+              `${SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Found matching NFT ID ${currentId} for owner ${owner.address}`,
+            );
+          }
+
+          currentId--;
+        } catch (e) {
+          // When owner_of throws an error, it means we've reached the last pending NFT
+          logger.info(
+            `${SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Reached last pending NFT at id ${currentId}`,
+          );
+          break;
+        }
+      }
+
+      if (matchingIds.length === 0) {
+        logger.info(
+          `${SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: No matching NFTs found for owner ${owner.address}`,
+        );
+        return Web3Number.fromWei("0", decimals);
+      }
+
+      // Step 4: For each matching ID, call id_to_info and sum up all nominal values
+      let totalNominal = 0n;
+
+      for (const nftId of matchingIds) {
+        try {
+          const idU256 = uint256.bnToUint256(nftId);
+          const infoRaw: any = await nftContract.id_to_info(idU256);
+
+          // The response is a struct with { epoch: u256, nominal: u256 }
+          const nominal = BigInt(infoRaw.nominal.toString());
+          totalNominal += nominal;
+
+          logger.debug(
+            `${SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: NFT ID ${nftId} has nominal ${nominal}`,
+          );
+        } catch (e) {
+          logger.warn(
+            `${SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Failed to get info for NFT ID ${nftId}: ${(e as Error).message}`,
+          );
+        }
+      }
+
+      logger.info(
+        `${SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Found ${matchingIds.length} NFTs with total nominal ${totalNominal}`,
+      );
+
+      return Web3Number.fromWei(totalNominal.toString(), decimals);
+    } catch (error) {
+      logger.error(
+        `${SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: ${(error as Error).message}`,
+      );
+      return Web3Number.fromWei("0", decimals);
+    }
+  }
+
+  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: "request_redeem",
+        packedArguments: [recv.toBigInt(), owner.toBigInt()],
+        sanitizer: SVK_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;
+
+    const vault = new Contract({
+      abi: universalVaultAbi as never,
+      address: strategyVault.address,
+      providerOrAccount: this.config.networkConfig.provider,
+    });
+    const sharesRaw: any = await vault.convert_to_shares(uint256Amount);
+    const sharesU256 = uint256.bnToUint256(sharesRaw.toString());
+
+    return [
+      {
+        proofReadableId: this._withdrawCallProofReadableId(),
+        sanitizer: SVK_SIMPLE_SANITIZER,
+        call: {
+          contractAddress: strategyVault,
+          selector: hash.getSelectorFromName("request_redeem"),
+          calldata: [
+            toBigInt(sharesU256.low.toString()),
+            toBigInt(sharesU256.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);
+  }
+}