@strkfarm/sdk 2.0.0-dev.4 → 2.0.0-dev.41

package/src/strategies/types.ts

@@ -0,0 +1,4 @@
+export enum LSTPriceType {
+  ENDUR_PRICE = 'ENDUR_PRICE',
+  AVNU_PRICE = 'AVNU_PRICE'
+}

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

@@ -2,6 +2,8 @@ import { ContractAddr } from "@/dataTypes";
 
 // Zellic audited
 export const SIMPLE_SANITIZER = ContractAddr.from('0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4');
+// Above SIMPLE_SANITIZER was not exposing the request_redeem method
+export const SVK_SIMPLE_SANITIZER = ContractAddr.from('0x03dcde04343257c3ce14574676cb9c5b2eda16e332c1b8caf5dc4c95ac568d2f')
 export const EXTENDED_SANITIZER = ContractAddr.from('0x65891708362b24dcf4c40c8e218cce6e82d1d6b3a3404c9ab00a48f08e2c110');
 export const AVNU_LEGACY_SANITIZER = ContractAddr.from('0x0656fBE853f116DD53956176a553eDe8fE65632252f8aceB50C1B9B6c8237309');
 // Without flashloan options
@@ -15,6 +17,7 @@ export const AVNU_EXCHANGE_FOR_LEGACY_USDC = ContractAddr.from('0x7bffc7f6bda62b
 export const AVNU_QUOTE_URL = "https://starknet.api.avnu.fi/swap/v3/quotes";
 export const EXTENDED_CONTRACT = ContractAddr.from('0x062da0780fae50d68cecaa5a051606dc21217ba290969b302db4dd99d2e9b470');
 export const VESU_SINGLETON = ContractAddr.from('0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160');
+export const TRANSFER_SANITIZER = ContractAddr.from('0x07c94fd8762b37b02c2afeaf37e5d77523a2aedd370ccff6e130b2d5e9e23037');
 export function toBigInt(value: string | number): bigint {
     if (typeof value === 'string') {
         return BigInt(value);
@@ -23,4 +26,4 @@ export function toBigInt(value: string | number): bigint {
     } else {
         throw new Error('Value must be a string or number');
     }
-}
+}

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

@@ -3,52 +3,206 @@ import {
   DepositParams,
   WithdrawParams,
   BaseAdapterConfig,
+  SwapPriceInfo,
 } from "./baseAdapter";
-import { SIMPLE_SANITIZER_V2, toBigInt } from "./adapter-utils";
+import { toBigInt } from "./adapter-utils";
 import { Protocols } from "@/interfaces";
-import { MAX_DELAY } from "../vesu-extended-strategy/utils/constants";
 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 { TokenInfo } from "@/interfaces";
 import { AVNU_EXCHANGE } from "./adapter-utils";
-import { MAX_RETRIES } from "../vesu-extended-strategy/utils/constants";
 import { Quote } from "@avnu/avnu-sdk";
 import { hash, uint256 } from "starknet";
 import { AvnuWrapper } from "@/modules/avnu";
 import axios from "axios";
-import { AVNU_MIDDLEWARE, SIMPLE_SANITIZER } from "./adapter-utils";
-import { returnFormattedAmount } from "../vesu-extended-strategy/utils/helper";
-import { logger } from "@/utils";
+import { SIMPLE_SANITIZER } from "./adapter-utils";
+import { assert, logger } from "@/utils";
+import { Global } from "@/global";
+import { TokenInfo } from "@/interfaces";
+import { ERC20 } from "@/modules";
+import { MAX_AVNU_RETRY_DELAY } from "../constants";
+
+export interface AvnuDepositParams extends DepositParams {
+  minAmount?: Web3Number;
+}
+
+export interface AvnuWithdrawParams extends WithdrawParams {
+  minAmount?: Web3Number;
+}
+
 export interface AvnuAdapterConfig extends BaseAdapterConfig {
   baseUrl: string;
   avnuContract: ContractAddr; //0x04270219d365d6b017231b52e92b3fb5d7c8378b05e9abc97724537a80e93b0f
   slippage: number;
+  minimumExtendedPriceDifferenceForSwapOpen: number;
+  maximumExtendedPriceDifferenceForSwapClosing: number;
 }
 
-export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+export class AvnuAdapter extends BaseAdapter<AvnuDepositParams, AvnuWithdrawParams> {
   readonly config: AvnuAdapterConfig;
   protected avnuWrapper: AvnuWrapper;
+  lastSwapPriceInfo: SwapPriceInfo | null = null;
+
+  private _depositApproveProofReadableId(): string {
+    return `approve_${this.config.supportedPositions[0].asset.symbol}`;
+  }
+
+  private _depositSwapProofReadableId(): string {
+    return `asutb_${this.config.supportedPositions[0].asset.symbol}_${this.config.supportedPositions[1].asset.symbol}`;
+  }
+
+  private _withdrawApproveProofReadableId(): string {
+    return `approve_${this.config.supportedPositions[1].asset.symbol}`;
+  }
+
+  private _withdrawSwapProofReadableId(): string {
+    const fromToken = this.config.supportedPositions[1].asset;
+    return `asbtu_${fromToken.symbol}_${fromToken.symbol}`;
+  }
+
+  private buildSwapLeafConfigs(
+    fromToken: TokenInfo,
+    toToken: TokenInfo,
+    swapId: string,
+  ): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const vaultAllocator = ContractAddr.from(this.config.vaultAllocator.address);
+    return [
+      {
+        target: fromToken.address,
+        method: "approve",
+        packedArguments: [AVNU_EXCHANGE.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approve_${fromToken.symbol}`,
+      },
+      {
+        target: AVNU_EXCHANGE,
+        method: "multi_route_swap",
+        packedArguments: [
+          fromToken.address.toBigInt(),
+          toToken.address.toBigInt(),
+          vaultAllocator.toBigInt(),
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: swapId,
+      },
+    ];
+  }
+
+  private async buildSwapCalls(
+    params: AvnuDepositParams | AvnuWithdrawParams,
+    fromToken: TokenInfo,
+    toToken: TokenInfo,
+    // NOTE : this is a direction flag that we are swapping in this direction
+    usdcToBtc: boolean,
+  ): Promise<ManageCall[]> {
+    const vaultAllocator = ContractAddr.from(this.config.vaultAllocator.address);
+    const quote = await this.avnuWrapper.getQuotes(
+      fromToken.address.toString(),
+      toToken.address.toString(),
+      params.amount.toWei(),
+      vaultAllocator.address.toString(),
+    );
+
+    if (!quote) {
+      logger.error("No quotes available for this swap, error in quotes avnu");
+      return [];
+    }
+
+    const fromAmt = Web3Number.fromWei(quote.sellAmount.toString(), fromToken.decimals).toNumber();
+    const toAmt = Web3Number.fromWei(quote.buyAmount.toString(), toToken.decimals).toNumber();
+    this.lastSwapPriceInfo = {
+      source: 'avnu',
+      fromTokenSymbol: fromToken.symbol,
+      toTokenSymbol: toToken.symbol,
+      fromAmount: fromAmt,
+      toAmount: toAmt,
+      effectivePrice: toAmt !== 0 ? fromAmt / toAmt : 0,
+    };
+    logger.verbose(
+      `${AvnuAdapter.name}::buildSwapCalls stored price info: ` +
+      `${fromAmt} ${fromToken.symbol} → ${toAmt} ${toToken.symbol}, ` +
+      `effectivePrice=${this.lastSwapPriceInfo.effectivePrice}`,
+    );
+
+    const getCalldata = await this.avnuWrapper.getSwapCallData(
+      quote,
+      vaultAllocator.address,
+      params.minAmount,
+    );
+    const swapCallData = getCalldata[0];
+    const approveAmount = uint256.bnToUint256(params.amount.toWei());
+
+    return [
+      {
+        proofReadableId: usdcToBtc
+          ? this._depositApproveProofReadableId()
+          : this._withdrawApproveProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: fromToken.address,
+          selector: hash.getSelectorFromName("approve"),
+          calldata: [
+            AVNU_EXCHANGE.toBigInt(),
+            toBigInt(approveAmount.low.toString()),
+            toBigInt(approveAmount.high.toString()),
+          ],
+        },
+      },
+      {
+        proofReadableId: usdcToBtc
+          ? this._depositSwapProofReadableId()
+          : this._withdrawSwapProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: AVNU_EXCHANGE,
+          selector: hash.getSelectorFromName("multi_route_swap"),
+          calldata: swapCallData,
+        },
+      },
+    ];
+  }
 
   constructor(config: AvnuAdapterConfig) {
     super(config, AvnuAdapter.name, Protocols.AVNU);
     this.config = config as AvnuAdapterConfig;
     this.avnuWrapper = new AvnuWrapper();
+    assert(this.config.supportedPositions.length === 2, "AvnuAdapter must have 2 supported positions");
   }
   //abstract means the method has no implementation in this class; instead, child classes must implement it.
   protected async getAPY(
-    supportedPosition: SupportedPosition
+    supportedPosition: SupportedPosition,
   ): Promise<PositionAPY> {
     return Promise.resolve({ apy: 0, type: APYType.BASE });
   }
 
   protected async getPosition(
-    supportedPosition: SupportedPosition
-  ): Promise<PositionAmount> {
-    return Promise.resolve({ amount: new Web3Number(0, 0), remarks: "" });
+    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(
+        supportedPosition.asset.address,
+        this.config.vaultAllocator.address,
+        supportedPosition.asset.decimals,
+      );
+      return { amount: balance, remarks: `Swapped Unused balance (VA)` };
+    } catch (_e) {
+      logger.error(`${AvnuAdapter.name}::getPosition: failed for ${toToken.symbol}`);
+      throw new Error(`${AvnuAdapter.name}: failed to get balance for ${toToken.symbol}`);
+    }
   }
 
   async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
@@ -81,31 +235,11 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     sanitizer: ContractAddr;
     id: string;
   }[] {
-    const vaultAllocator = ContractAddr.from(
-      this.config.vaultAllocator.address
+    return this.buildSwapLeafConfigs(
+      this.config.supportedPositions[0].asset,
+      this.config.supportedPositions[1].asset,
+      this._depositSwapProofReadableId(),
     );
-    return [
-      {
-        target: this.config.supportedPositions[0].asset.address,
-        method: "approve",
-        packedArguments: [
-          AVNU_EXCHANGE.toBigInt(),
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `approve_${this.config.supportedPositions[0].asset.symbol}`,
-      },
-      {
-        target: AVNU_EXCHANGE,
-        method: "multi_route_swap",
-        packedArguments: [
-          this.config.supportedPositions[0].asset.address.toBigInt(), //usdc
-          this.config.supportedPositions[1].asset.address.toBigInt(), //wbtc
-          vaultAllocator.toBigInt(),
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `asutb_${this.config.supportedPositions[0].asset.symbol}_${this.config.supportedPositions[1].asset.symbol}`,
-      },
-    ];
   }
 
   protected _getWithdrawLeaf(): {
@@ -115,33 +249,13 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     sanitizer: ContractAddr;
     id: string;
   }[] {
-    const vaultAllocator = ContractAddr.from(
-      this.config.vaultAllocator.address
-    );
     const toToken = this.config.supportedPositions[0].asset;
     const fromToken = this.config.supportedPositions[1].asset;
-    return [
-      {
-        target: fromToken.address,
-        method: "approve",
-        packedArguments: [
-          AVNU_EXCHANGE.toBigInt(),
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `approve_${fromToken.symbol}`,
-      },
-      {
-        target: AVNU_EXCHANGE,
-        method: "multi_route_swap",
-        packedArguments: [
-          fromToken.address.toBigInt(), //wbtc
-          toToken.address.toBigInt(), //usdc
-          vaultAllocator.toBigInt(),
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `asbtu_${fromToken.symbol}_${fromToken.symbol}`,
-      },
-    ];
+    return this.buildSwapLeafConfigs(
+      fromToken,
+      toToken,
+      this._withdrawSwapProofReadableId(),
+    );
   }
 
   protected _getLegacySwapLeaf(): {
@@ -154,57 +268,17 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     return [];
   }
 
-  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+  async getDepositCall(params: AvnuDepositParams): Promise<ManageCall[]> {
     try {
       const fromToken = this.config.supportedPositions[0].asset; //usdc
       const toToken = this.config.supportedPositions[1].asset; //wbtc
-      const vaultAllocator = ContractAddr.from(
-        this.config.vaultAllocator.address
+      const calls = await this.buildSwapCalls(
+        params,
+        fromToken,
+        toToken,
+        true,
       );
-      const quote = await this.getQuotesAvnu(
-        fromToken.address.toString(),
-        toToken.address.toString(),
-        params.amount.toNumber(),
-        vaultAllocator.address.toString(),
-        toToken.decimals,
-        true
-      )
-      //console.log(`${AvnuAdapter.name}::getDepositCall quote: ${JSON.stringify(quote)}`);
-      if (!quote) {
-        logger.error("error getting quote from avnu");
-        return [];
-      }
-
-      const getCalldata = await this.avnuWrapper.getSwapCallData(
-        quote,
-        vaultAllocator.address
-      );
-      const swapCallData = getCalldata[0];
-      
-      // const approveCallData = getCalldata[0];
-      const amount = uint256.bnToUint256(quote.sellAmountInUsd*10**7)
-      return [
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: fromToken.address,
-            selector: hash.getSelectorFromName("approve"),
-            calldata:[
-              AVNU_EXCHANGE.toBigInt(),
-              toBigInt(amount.low.toString()), // amount low
-              toBigInt(amount.high.toString()), // amount high
-            ] ,
-          },
-        },
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: AVNU_EXCHANGE,
-            selector: hash.getSelectorFromName("multi_route_swap"),
-            calldata: swapCallData,
-          },
-        },
-      ];
+      return calls;
     } catch (error) {
       logger.error(`Error getting Avnu quote: ${error}`);
       return [];
@@ -212,53 +286,17 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
   }
 
   //Swap wbtc to usdc
-  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+  async getWithdrawCall(params: AvnuWithdrawParams): Promise<ManageCall[]> {
     try {
       const toToken = this.config.supportedPositions[0].asset;
       const fromToken = this.config.supportedPositions[1].asset;
-      const vaultAllocator = ContractAddr.from(
-        this.config.vaultAllocator.address
-      );
-      const quote = await this.getQuotesAvnu(
-        fromToken.address.toString(),
-        toToken.address.toString(),
-        params.amount.toNumber(),
-        vaultAllocator.address.toString(),
-        fromToken.decimals,
-        false
-      );
-      if (!quote) {
-        logger.error("No quotes available for this swap, error in quotes avnu");
-        return [];
-      }
-      const getCalldata = await this.avnuWrapper.getSwapCallData(
-        quote,
-        vaultAllocator.address
+      const calls = await this.buildSwapCalls(
+        params,
+        fromToken,
+        toToken,
+        false,
       );
-      const swapCallData = getCalldata[0];
-      const amount = uint256.bnToUint256(params.amount.toWei())
-      return [
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress:fromToken.address,
-            selector: hash.getSelectorFromName("approve"),
-            calldata: [
-              AVNU_EXCHANGE.toBigInt(),
-              toBigInt(amount.low.toString()), // amount low
-              toBigInt(amount.high.toString()), // amount high
-            ],
-          },
-        },
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: AVNU_EXCHANGE,
-            selector: hash.getSelectorFromName("multi_route_swap"),
-            calldata: swapCallData,
-          },
-        },
-      ];
+      return calls;
     } catch (error) {
       logger.error(`Error getting Avnu quote: ${error}`);
       return [];
@@ -266,7 +304,10 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
   }
 
   async getSwapCallData(quote: Quote): Promise<bigint[][]> {
-    return await this.avnuWrapper.getSwapCallData(quote, this.config.vaultAllocator.address);
+    return await this.avnuWrapper.getSwapCallData(
+      quote,
+      this.config.vaultAllocator.address,
+    );
   }
 
   async getHealthFactor(): Promise<number> {
@@ -275,7 +316,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
 
   async fetchQuoteWithRetry(
     params: Record<string, any>,
-    retries: number = 5
+    retries: number = 5,
   ): Promise<any> {
     for (let attempt = 0; attempt < retries; attempt++) {
       try {
@@ -289,126 +330,9 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
         if (attempt === retries - 1) {
           throw err;
         }
-        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
+        await new Promise((resolve) => setTimeout(resolve, MAX_AVNU_RETRY_DELAY));
       }
     }
     throw new Error("Failed to fetch quote after retries");
   }
-
-  async getQuotesAvnu (
-    from_token_address: string,
-    to_token_address: string,
-    amount: number, //amount in btc units
-    takerAddress: string,
-    toTokenDecimals: number,
-    usdcToBtc: boolean,
-    maxIterations: number = 5,
-    tolerance: number = 1000
-  ): Promise<Quote | null>{
-    try {
-      const fromToken = this.config.supportedPositions[0].asset;
-      const toToken = this.config.supportedPositions[1].asset;
-      if(!usdcToBtc) {
-        const sellAmount = returnFormattedAmount(amount, toTokenDecimals);
-        const params: Record<string, any> = {
-          sellTokenAddress: from_token_address,
-          buyTokenAddress: to_token_address,
-          takerAddress,
-          sellAmount:sellAmount,
-        };
-        const finalQuote = await this.fetchQuoteWithRetry(params);
-        if (!finalQuote.data.length) {
-          logger.error("No quotes available for this swap, error in quotes avnu");
-          return null;
-        }
-        const dataObject: Quote = finalQuote.data[0];
-        return dataObject;
-      }
-      const btcPrice = await this.getPriceOfToken(toToken.address.toString());
-      if (!btcPrice) {
-        logger.error(`error getting btc price: ${btcPrice}`);
-        return null;
-      }
-      const estimatedUsdcAmount = Math.floor(amount * btcPrice);
-      const targetBtcBig = BigInt(returnFormattedAmount(amount, toTokenDecimals));
-      let low = BigInt(
-        Math.floor(
-          (estimatedUsdcAmount * 10 ** fromToken.decimals) * 0.9
-        )
-      );
-      let high = BigInt(
-        Math.floor(
-          (estimatedUsdcAmount * 10 ** fromToken.decimals) * 1.1
-        )
-      );
-      let mid = 0n;
-      for (let i = 0; i < maxIterations; i++) {
-        mid = (low + high) / 2n;
-        const sellAmount = returnFormattedAmount(Number(mid), 0);
-        const quote = await this.fetchQuoteWithRetry({
-          sellTokenAddress: from_token_address,
-          buyTokenAddress: to_token_address,
-          takerAddress,
-          sellAmount,
-        });
-  
-        const gotBtc = BigInt(quote.data[0].buyAmount);
-        if (gotBtc === targetBtcBig) return quote.data[0];
-  
-        if (gotBtc > targetBtcBig) {
-          high = mid;
-        } else {
-          low = mid;
-        }
-  
-        if (
-          gotBtc >= targetBtcBig &&
-          gotBtc <= targetBtcBig + BigInt(tolerance)
-        ) {
-          return quote.data[0];
-        }
-      }
-      let sellAmount = returnFormattedAmount(
-        Number(mid),
-        0
-      );
-      const params: Record<string, any> = {
-        sellTokenAddress: from_token_address,
-        buyTokenAddress: to_token_address,
-        takerAddress,
-        sellAmount: sellAmount,
-      };
-      const finalQuote = await this.fetchQuoteWithRetry(params);
-      if (!finalQuote.data.length) {
-        logger.error("No quotes available for this swap, error in quotes avnu");
-        return null;
-      }
-      const dataObject: Quote = finalQuote.data[0];
-      return dataObject;
-    } catch (err) {
-      logger.error(`No quotes available for this swap: ${err}`);
-      return null;
-    }
-  };
-
-  async getPriceOfToken (
-    tokenAddress: string,
-    retries: number = MAX_RETRIES
-  ): Promise<number | null> {
-    try {
-      const url = `https://starknet.impulse.avnu.fi/v1/tokens/${tokenAddress}/prices/line`;
-      const response = await axios.get(url);
-      const length = response.data.length;
-      return response.data[length - 1].value;
-    } catch (err) {
-      if (retries > 0) {
-        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
-        return this.getPriceOfToken(tokenAddress, retries - 1);
-      } else {
-        logger.error(`Failed to fetch price for ${tokenAddress} after ${MAX_RETRIES} attempts`);
-        return null;
-      }
-    }
-  };
-
-}
+}