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

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

@@ -1,9 +1,10 @@
-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 "./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";

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);
+  }
+}

package/src/strategies/universal-adapters/usdc<>usdce-adapter.ts

@@ -0,0 +1,200 @@
+import {
+  BaseAdapter,
+  DepositParams,
+  WithdrawParams,
+  BaseAdapterConfig,
+} from "./baseAdapter";
+import { toBigInt } from "./adapter-utils";
+import { Protocols } from "@/interfaces";
+import { SupportedPosition } from "./baseAdapter";
+import { PositionAPY, APYType, PositionAmount } from "./baseAdapter";
+import { Web3Number } from "@/dataTypes";
+import { PositionInfo } from "./baseAdapter";
+import { ManageCall } from "./baseAdapter";
+import { ContractAddr } from "@/dataTypes";
+import { AVNU_EXCHANGE } from "./adapter-utils";
+import { hash, uint256 } from "starknet";
+import { AVNU_EXCHANGE_FOR_LEGACY_USDC } from "./adapter-utils";
+import { AVNU_LEGACY_SANITIZER } from "./adapter-utils";
+import { assert, logger } from "@/utils";
+import { ERC20 } from "@/modules";
+
+export class UsdcToUsdceAdapter extends BaseAdapter<
+  DepositParams,
+  WithdrawParams
+> {
+  readonly config: BaseAdapterConfig;
+
+  private _approveProofReadableId(usdcToUsdce: boolean): string {
+    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
+    return `approve_${method}`;
+  }
+
+  private _swapProofReadableId(usdcToUsdce: boolean): string {
+    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
+    const target = usdcToUsdce
+      ? this.config.supportedPositions[0].asset
+      : this.config.supportedPositions[1].asset;
+    return `${method}_${target.symbol}`;
+  }
+
+  private buildSwapLeafConfigs(usdcToUsdce: boolean): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
+    const target = usdcToUsdce
+      ? this.config.supportedPositions[0].asset
+      : this.config.supportedPositions[1].asset;
+    return [
+      {
+        target: target.address,
+        method: "approve",
+        packedArguments: [AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()],
+        id: this._approveProofReadableId(usdcToUsdce),
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+      {
+        target: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+        method: method,
+        packedArguments: [],
+        id: this._swapProofReadableId(usdcToUsdce),
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+    ];
+  }
+
+  private async buildSwapCalls(
+    params: DepositParams | WithdrawParams,
+    usdcToUsdce: boolean,
+  ): Promise<ManageCall[]> {
+    const approveAmount = uint256.bnToUint256(params.amount.toWei());
+    const target = usdcToUsdce
+      ? this.config.supportedPositions[0].asset
+      : this.config.supportedPositions[1].asset;
+    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
+    return [
+      {
+        proofReadableId: this._approveProofReadableId(usdcToUsdce),
+        sanitizer: AVNU_LEGACY_SANITIZER,
+        call: {
+          contractAddress: target.address,
+          selector: hash.getSelectorFromName("approve"),
+          calldata: [
+            AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
+            toBigInt(approveAmount.low.toString()),
+            toBigInt(approveAmount.high.toString()),
+          ],
+        },
+      },
+      {
+        proofReadableId: this._swapProofReadableId(usdcToUsdce),
+        sanitizer: AVNU_LEGACY_SANITIZER,
+        call: {
+          contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+          selector: hash.getSelectorFromName(method),
+          calldata: [
+            toBigInt(approveAmount.low.toString()), // amount low
+            toBigInt(approveAmount.high.toString()), // amount high
+          ],
+        },
+      },
+    ];
+  }
+
+  constructor(config: BaseAdapterConfig) {
+    super(config, UsdcToUsdceAdapter.name, Protocols.AVNU);
+    this.config = config as BaseAdapterConfig;
+    assert(this.config.supportedPositions.length === 2, "UsdcToUsdceAdapter must have 2 supported positions");
+    assert(this.config.supportedPositions[0].asset.symbol === "USDC", "UsdcToUsdceAdapter must have USDC as the first supported position");
+    assert(this.config.supportedPositions[1].asset.symbol === "USDC.e", "UsdcToUsdceAdapter must have USDCE as the second supported position");
+  }
+  //abstract means the method has no implementation in this class; instead, child classes must implement it.
+  protected async getAPY(
+    supportedPosition: SupportedPosition,
+  ): Promise<PositionAPY> {
+    return Promise.resolve({ apy: 0, type: APYType.BASE });
+  }
+
+  protected async getPosition(
+    supportedPosition: SupportedPosition,
+  ): Promise<PositionAmount | null> {
+    const toToken = this.config.supportedPositions[1].asset;
+    if (supportedPosition.asset.symbol != toToken.symbol) {
+      return null;
+    }
+    try {
+      // only measure balance of toToken, bcz from token usually gets trakced in unused balance or a previous avnu adapter
+      const balance = await new ERC20(this.config.networkConfig).balanceOf(
+        toToken.address,
+        this.config.vaultAllocator.address,
+        toToken.decimals,
+      );
+      return { amount: balance, remarks: `USDC.e unused balance (VA)` };
+    } catch (_e) {
+      logger.error(`${UsdcToUsdceAdapter.name}::getPosition: failed for ${toToken.symbol}`);
+      throw new Error(`${UsdcToUsdceAdapter.name}: failed to get balance for ${toToken.symbol}`);
+    }
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    return Promise.resolve({
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, 0),
+      usdValue: 0,
+      apy: { apy: 0, type: APYType.BASE },
+      protocol: Protocols.AVNU,
+      remarks: "",
+    });
+  }
+
+  async maxWithdraw(): Promise<PositionInfo> {
+    return Promise.resolve({
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, 0),
+      usdValue: 0,
+      apy: { apy: 0, type: APYType.BASE },
+      protocol: Protocols.AVNU,
+      remarks: "",
+    });
+  }
+
+  protected _getDepositLeaf(): {
+    // considering deposit is converting usdc to usdce
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    return this.buildSwapLeafConfigs(true);
+  }
+
+  protected _getWithdrawLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    return this.buildSwapLeafConfigs(false);
+  }
+
+  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+      const calls = await this.buildSwapCalls(params, true);
+      return calls;
+  }
+
+  //Swap wbtc to usdc
+  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+      const calls = await this.buildSwapCalls(params, false);
+      return calls;
+  }
+
+  async getHealthFactor(): Promise<number> {
+    return Promise.resolve(1);
+  }
+}