@strkfarm/sdk 1.2.0 → 2.0.0-dev-strategy2.1

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

@@ -0,0 +1,432 @@
+import {
+  BaseAdapter,
+  DepositParams,
+  WithdrawParams,
+  BaseAdapterConfig,
+} from "./baseAdapter";
+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 { 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 {SIMPLE_SANITIZER } from "./adapter-utils";
+import { returnFormattedAmount } from "../vesu-extended-strategy/utils/helper";
+import { logger } from "@/utils";
+export interface AvnuAdapterConfig extends BaseAdapterConfig {
+  baseUrl: string;
+  avnuContract: ContractAddr; //0x04270219d365d6b017231b52e92b3fb5d7c8378b05e9abc97724537a80e93b0f
+  slippage: number;
+  minimumExtendedPriceDifferenceForSwapOpen: number;
+  maximumExtendedPriceDifferenceForSwapClosing: number;
+}
+
+export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+  readonly config: AvnuAdapterConfig;
+  protected avnuWrapper: AvnuWrapper;
+
+  constructor(config: AvnuAdapterConfig) {
+    super(config, AvnuAdapter.name, Protocols.AVNU);
+    this.config = config as AvnuAdapterConfig;
+    this.avnuWrapper = new AvnuWrapper();
+  }
+  //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> {
+    return Promise.resolve({ amount: new Web3Number(0, 0), remarks: "" });
+  }
+
+  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 wbtc
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const vaultAllocator = ContractAddr.from(
+      this.config.vaultAllocator.address
+    );
+    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(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    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}`,
+      },
+    ];
+  }
+
+  protected _getLegacySwapLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    return [];
+  }
+
+  async getDepositCall(params: DepositParams): 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 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 [];
+      }
+      logger.info(`${this.name}::getDepositCall quote: ${quote.sellAmountInUsd}`);
+      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,
+          },
+        },
+      ];
+    } catch (error) {
+      logger.error(`Error getting Avnu quote: ${error}`);
+      return [];
+    }
+  }
+
+  //Swap wbtc to usdc
+  async getWithdrawCall(params: WithdrawParams): 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 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,
+          },
+        },
+      ];
+    } catch (error) {
+      logger.error(`Error getting Avnu quote: ${error}`);
+      return [];
+    }
+  }
+
+  async getSwapCallData(quote: Quote): Promise<bigint[][]> {
+    return await this.avnuWrapper.getSwapCallData(quote, this.config.vaultAllocator.address);
+  }
+
+  async getHealthFactor(): Promise<number> {
+    return Promise.resolve(1);
+  }
+
+  async fetchQuoteWithRetry(
+    params: Record<string, any>,
+    retries: number = 5
+  ): Promise<any> {
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        const response = await axios.get(this.config.baseUrl, { params });
+        if (response.data && response.data.length > 0) {
+          return response;
+        }
+        throw new Error("Empty response data");
+      } catch (err) {
+        logger.error(`Error fetching quote with retry: ${err}`);
+        if (attempt === retries - 1) {
+          throw err;
+        }
+        await new Promise((resolve) => setTimeout(resolve, attempt * MAX_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 = 5000
+  ): 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));
+      
+      // Check if the amount is too small - if estimated USDC amount is 0 or target BTC is 0, skip
+      if (estimatedUsdcAmount === 0 || targetBtcBig === 0n) {
+        logger.warn(`${AvnuAdapter.name}::getQuotesAvnu Amount too small: estimatedUsdcAmount=${estimatedUsdcAmount}, targetBtcBig=${targetBtcBig.toString()}, amount=${amount}`);
+        return null;
+      }
+      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;
+        // Skip if mid is 0 to avoid fetching quotes with 0 amount
+        if (mid === 0n) {
+          logger.warn(`${AvnuAdapter.name}::getQuotesAvnu Binary search resulted in 0 amount, stopping search`);
+          break;
+        }
+        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];
+        }
+      }
+      // Check if mid is still 0 before final quote fetch
+      if (mid === 0n) {
+        logger.warn(`${AvnuAdapter.name}::getQuotesAvnu Final mid value is 0, cannot fetch quote`);
+        return null;
+      }
+      
+      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;
+      }
+    }
+  };
+
+}