@strkfarm/sdk 1.1.70 → 2.0.0-dev.1

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

@@ -0,0 +1,544 @@
+import { BaseAdapter, DepositParams, WithdrawParams, BaseAdapterConfig } from "./baseAdapter";
+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_FOR_LEGACY_USDC } from "./adapter-utils";
+import { hash, uint256 } from "starknet";
+import { Global } from "@/global";
+import { AVNU_LEGACY_SANITIZER, EXTENDED_SANITIZER, SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import ExtendedWrapper, {
+  AssetOperationStatus,
+  AssetOperationType,
+  FundingRate,
+  OrderSide,
+  Position,
+  TimeInForce,
+} from "@/modules/ExtendedWrapperSDk";
+import { Balance, OpenOrder, OrderStatus } from "@/modules/ExtendedWrapperSDk";
+import axios from "axios";
+import { AvnuAdapter } from "./avnu-adapter";
+import { logger } from "@/utils";
+export interface ExtendedAdapterConfig extends BaseAdapterConfig {
+  vaultIdExtended: number;
+  extendedContract: ContractAddr; //0x04270219d365d6b017231b52e92b3fb5d7c8378b05e9abc97724537a80e93b0f
+  extendedBackendUrl: string;
+  extendedApiKey: string;
+  extendedTimeout: number;
+  extendedRetries: number;
+  extendedBaseUrl: string;
+  extendedMarketName: string;
+  extendedPrecision: number;
+  avnuAdapter: AvnuAdapter;
+}
+
+export class ExtendedAdapter extends BaseAdapter<
+  DepositParams,
+  WithdrawParams
+> {
+  readonly config: ExtendedAdapterConfig;
+  readonly client: ExtendedWrapper;
+
+  constructor(config: ExtendedAdapterConfig) {
+    super(config, ExtendedAdapter.name, Protocols.EXTENDED);
+    this.config = config as ExtendedAdapterConfig;
+    const client = new ExtendedWrapper({
+      baseUrl: this.config.extendedBackendUrl,
+      apiKey: this.config.extendedApiKey,
+      timeout: this.config.extendedTimeout,
+      retries: this.config.extendedRetries,
+    });
+    this.client = client;
+  }
+  //abstract means the method has no implementation in this class; instead, child classes must implement it.
+  protected async getAPY(
+    supportedPosition: SupportedPosition
+  ): Promise<PositionAPY> {
+    /** Considering supportedPosiiton.isDebt as side parameter to get the funding rates */
+    const side = supportedPosition.isDebt ? "LONG" : "SHORT";
+    const fundingRates = await this.client.getFundingRates(this.config.extendedMarketName, side);
+    if (fundingRates.status !== "OK") {
+      logger.error("error getting funding rates", fundingRates);
+      return { apy: 0, type: APYType.BASE };
+    }
+    const fundingRate:FundingRate = fundingRates.data[0];
+    const apy = Number(fundingRate.f) * 365 * 24;
+    return { apy: apy, type: APYType.BASE };
+  }
+
+  protected async getPosition(
+    supportedPosition: SupportedPosition
+  ): Promise<PositionAmount> {
+    if (!this.client) {
+      throw new Error("Client not initialized");
+    }
+    const holdings = await this.getExtendedDepositAmount();
+    if (!holdings) {
+      throw new Error("No position found");
+    }
+    // equity is the total amount on extended
+    const amount = holdings.equity;
+    return Promise.resolve({
+      amount: new Web3Number(amount, 0),
+      remarks: `${holdings.availableForWithdrawal} ${holdings.equity}`,
+    });
+  }
+
+  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.EXTENDED,
+      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.EXTENDED,
+      remarks: "",
+    });
+  }
+
+  protected _getDepositLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const usdceToken = Global.getDefaultTokens().find(token => token.symbol === "USDCe");
+    return [
+      {
+        target: this.config.supportedPositions[0].asset.address,
+        method: "approve",
+        packedArguments: [
+          AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
+        ],
+        id: `extended_approve_${this.config.supportedPositions[0].asset.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+      {
+        target: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+        method: "swap_to_legacy",
+        packedArguments: [],
+        id: `extended_swap_to_legacy_${this.config.supportedPositions[0].asset.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+      {
+        target: usdceToken!.address,
+        method: "approve",
+        packedArguments: [this.config.extendedContract.toBigInt()],
+        id: `extended_approve_${usdceToken!.symbol}`,
+        sanitizer: SIMPLE_SANITIZER,
+      },
+      {
+        target: this.config.extendedContract,
+        method: "deposit",
+        packedArguments: [BigInt(this.config.vaultIdExtended)],
+        sanitizer: EXTENDED_SANITIZER,
+        id: `extended_deposit_${usdceToken!.symbol}`,
+      },
+    ];
+  }
+
+  protected _getWithdrawLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    /**
+     * Withdraw is done via extended wrapper
+     */
+    return [];
+  }
+
+  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+    try {
+      const usdcToken = this.config.supportedPositions[0].asset;
+      const usdceToken = Global.getDefaultTokens().find(token => token.symbol === "USDCe");
+      const salt = Math.floor(
+        Math.random() * 10 ** usdcToken.decimals
+      );
+      const amount = uint256.bnToUint256(params.amount.multipliedBy(10).toWei());
+      const quotes = await this.config.avnuAdapter.getQuotesAvnu(
+        usdcToken.address.toString(),
+        usdceToken!.address.toString(),
+        params.amount.toNumber(),
+        this.config.avnuAdapter.config.vaultAllocator.address.toString(),
+        usdceToken!.decimals,
+        false
+      )
+
+      if (!quotes) {
+        logger.error("error getting quotes from avnu");
+        return [];
+      }
+
+      const getCalldata = await this.config.avnuAdapter.getSwapCallData(quotes!);
+      const swapCallData = getCalldata[0];
+       //change extended sanitizer here
+      return [
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: usdcToken.address,
+            selector: hash.getSelectorFromName("approve"),
+            calldata: [
+              AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
+              toBigInt(amount.low.toString()), // amount low
+              toBigInt(amount.high.toString()), // amount high
+            ],
+          },
+        },
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+            selector: hash.getSelectorFromName("swap_to_legacy"),
+            calldata: swapCallData,
+          },
+        },
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: usdceToken!.address,
+            selector: hash.getSelectorFromName("approve"),
+            calldata: [
+              this.config.extendedContract.toBigInt(),
+              toBigInt(amount.low.toString()), // amount low
+              toBigInt(amount.high.toString()), // amount high
+            ],
+          },
+        },
+        {
+          sanitizer: EXTENDED_SANITIZER,
+          call: {
+            contractAddress: this.config.extendedContract,
+            selector: hash.getSelectorFromName("deposit"),
+            calldata: [
+              BigInt(this.config.vaultIdExtended),
+              BigInt(params.amount.toWei()),
+              BigInt(salt),
+            ],
+          },
+        },
+      ];
+    } catch (error) {
+      logger.error(`Error creating Deposit Call: ${error}`);
+      return [];
+    }
+  }
+
+  //Swap wbtc to usdc
+  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+    try {
+      if (!this.client) {
+        throw new Error("Client not initialized");
+      }
+      return [];
+    } catch (error) {
+      logger.error(`Error creating Withdraw Call: ${error}`);
+      return [];
+    }
+  }
+
+  async withdrawFromExtended(amount: Web3Number): Promise<boolean> {
+    try {
+      if (!this.client) {
+        throw new Error("Client not initialized");
+      }
+      const withdrawalRequest = this.client.withdrawUSDC(amount.toString());
+      if ((await withdrawalRequest).status === "OK") {
+        console.log("Withdrawal request successful");
+        return true;
+      }
+      return false;
+    } catch (error) {
+      logger.error(`Error creating Withdraw Call: ${error}`);
+      return false;
+    }
+  }
+
+  async getHealthFactor(): Promise<number> {
+    return Promise.resolve(1);
+  }
+
+  async getExtendedDepositAmount(): Promise<Balance | undefined> {
+    if (this.client === null) {
+      logger.error("error initializing client");
+      return undefined;
+    }
+    const result = await this.client.getHoldings();
+    if (!result) {
+      logger.error(`error getting holdings: ${result}`);
+      return undefined;
+    }
+    const holdings = result.data;
+    if (!holdings) {
+      logger.error(`error getting holdings: ${holdings}`);
+      return undefined;
+    }
+    return holdings;
+  }
+
+  async setLeverage(leverage: string, marketName: string): Promise<boolean> {
+    if (this.client === null) {
+      logger.error("error initializing client");
+      return false;
+    }
+    const res = await this.client.updateLeverage({
+      leverage: leverage,
+      market: marketName,
+    });
+    if (res.status === "OK") {
+      return true;
+    }
+    return false;
+  }
+
+  async getAllOpenPositions(): Promise<Position[] | null> {
+    if (this.client === null) {
+      logger.error("error initializing client");
+      return null;
+    }
+    const response = await this.client.getPositionsForMarket(
+      this.config.extendedMarketName
+    );
+    if (response.status === "OK") {
+      if (response.data.length === 0) {
+        return [];
+      } else {
+        return response.data;
+      }
+    }
+    return null;
+  }
+
+  async getOrderHistory(marketName: string): Promise<OpenOrder[] | null> {
+    if (this.client === null) {
+      logger.error("error initializing client");
+      return null;
+    }
+    const result = await this.client.getOrderHistory(marketName);
+    return result.data;
+  }
+
+  async getOrderStatus(
+    orderId: string,
+    marketName: string
+  ): Promise<OpenOrder | null> {
+    if (this.client === null) {
+      logger.error("error initializing client");
+      return null;
+    }
+    const orderhistory = await this.getOrderHistory(marketName);
+
+    if (!orderhistory || orderhistory.length === 0) {
+      logger.error(`error getting order: ${orderId}`);
+      return null;
+    }
+    const order = orderhistory
+      .slice(0, 3)
+      .find((order) => order.id.toString() === orderId);
+    if (!order) {
+      logger.error(`error getting order: ${order}`);
+      return null;
+    }
+    return order;
+  }
+
+  async fetchOrderBookBTCUSDC(): Promise<{
+    status: boolean;
+    bid: Web3Number;
+    ask: Web3Number;
+  }> {
+    try {
+      const res = await axios.get(
+        `${this.config.extendedBaseUrl}/api/v1/info/markets/${this.config.extendedMarketName}/orderbook`
+      );
+      let ask_price = new Web3Number(0, 0);
+      let bid_price = new Web3Number(0, 0);
+      if (res.data.status !== "OK") {
+        return {
+          status: false,
+          bid: bid_price,
+          ask: ask_price,
+        };
+      }
+      const data = res.data.data;
+      const bid = data.bid[0];
+      const ask = data.ask[0];
+      ask_price = new Web3Number(ask.price, 0);
+      bid_price = new Web3Number(bid.price, 0);
+
+      return {
+        status: false,
+        bid: bid_price, // check for quantity as well, not at the moment though
+        ask: ask_price, // check for quantity as well, not at the moment though
+      };
+    } catch (err) {
+      logger.error(`the err is: ${err}`);
+      return {
+        status: false,
+        bid: new Web3Number(0, 0),
+        ask: new Web3Number(0, 0),
+      };
+    }
+  }
+
+  async createOrder(
+    leverage: string,
+    btcAmount: number,
+    side: OrderSide,
+    attempt = 1,
+    maxAttempts = 5
+  ): Promise<{ position_id: string; btc_exposure: string } | null> {
+    try {
+      if (this.client === null) {
+        logger.error("error initializing client");
+        return null;
+      }
+      const setLeverage = await this.setLeverage(
+        leverage,
+        this.config.extendedMarketName
+      );
+      if (!setLeverage) {
+        logger.error("error depositing or setting leverage");
+        return null;
+      }
+      const positions = await this.getAllOpenPositions();
+      if (positions === null) {
+        return null;
+      }
+      const { ask, bid } = await this.fetchOrderBookBTCUSDC();
+      const spread = ask.minus(bid);
+      let price = ask
+        .plus(bid)
+        .div(2)
+      side === OrderSide.SELL ? price = price.minus(spread.times(0.2 * attempt)) : price = price.plus(spread.times(0.2 * attempt));
+      const amount_in_token = (btcAmount * parseInt(leverage)).toFixed(
+        this.config.extendedPrecision
+      ); // gives the amount of wbtc
+
+      const result = await this.createExtendedPositon(
+        this.client,
+        this.config.extendedMarketName,
+        amount_in_token,
+        price.toFixed(0),
+        side
+      );
+      if (!result) {
+        return null;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+      const openOrder = await this.getOrderStatus(result.position_id, this.config.extendedMarketName);
+      if (!openOrder || openOrder.status !== OrderStatus.FILLED) {
+        if (attempt >= maxAttempts) {
+          logger.error("Max retries reached — could not verify open position");
+          return null;
+        } else {
+          const backoff = 2000 * attempt;
+          await new Promise((resolve) => setTimeout(resolve, backoff));
+          return this.createOrder(
+            leverage,
+            btcAmount,
+            side,
+            attempt + 1,
+            maxAttempts
+          );
+        }
+      } else {
+        return {
+          position_id: result.position_id,
+          btc_exposure: openOrder.qty,
+        };
+      }
+    } catch (err: any) {
+      logger.error(`createShortOrder failed on attempt ${attempt}: ${err.message}`);
+
+      if (attempt < maxAttempts) {
+        const backoff = 1200 * attempt;
+        console.log(`Retrying after ${backoff}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, backoff));
+        return this.createOrder(
+          leverage,
+          btcAmount,
+          side,
+          attempt + 1,
+          maxAttempts
+        );
+      }
+      logger.error("Max retry attempts reached — aborting createShortOrder");
+      return null;
+    }
+  }
+
+  async createExtendedPositon(
+    client: ExtendedWrapper,
+    marketName: string,
+    amount: string,
+    price: string,
+    side: OrderSide
+  ) {
+    try {
+      const result =
+        side === OrderSide.SELL
+          ? await client.createSellOrder(marketName, amount, price, {
+              postOnly: false,
+              timeInForce: TimeInForce.IOC,
+            })
+          : await client.createBuyOrder(marketName, amount, price, {
+              postOnly: false,
+              timeInForce: TimeInForce.IOC,
+            });
+      if (result.data.id) {
+        const position_id = result.data.id.toString();
+        return {
+          position_id,
+        };
+      }
+      return null;
+    } catch (err) {
+      console.log("Error opening short extended position", err);
+      return null;
+    }
+  }
+
+  async getDepositOrWithdrawalStatus(orderId: number | string, operationsType: AssetOperationType): Promise<boolean> {
+    try{
+      let transferHistory = await this.client.getAssetOperations({
+        operationsType:[operationsType],
+        operationsStatus:[AssetOperationStatus.COMPLETED]
+      })
+      console.log("transferHistory", transferHistory);
+      if(operationsType === AssetOperationType.DEPOSIT){
+        const myTransferStatus = transferHistory.data.find(operation => operation.transactionHash === orderId);
+        if (!myTransferStatus) {
+          return false;
+        }
+        return true;
+      }else{
+        const myTransferStatus = transferHistory.data.find(operation => operation.id === orderId);
+        if (!myTransferStatus) {
+          return false;
+        }
+        return true;
+      }
+    }catch(err){
+      logger.error(`error getting deposit or withdrawal status: ${err}`);
+      return false;
+    }
+  }
+}

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

@@ -1,4 +1,8 @@
 export * from "./baseAdapter";
 export * from "./common-adapter";
 export * from "./vesu-adapter";
-export * from "./adapter-utils";
+export * from "./vesu-supply-only-adapter";
+export * from "./vesu-multiply-adapter";
+export * from "./extended-adapter";
+export * from "./adapter-utils";
+export * from "./unused-balance-adapter";

package/src/strategies/universal-adapters/unused-balance-adapter.ts

@@ -0,0 +1,109 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { APYType, BaseAdapter, BaseAdapterConfig, DepositParams, ManageCall, PositionAmount, PositionAPY, PositionInfo, SupportedPosition, WithdrawParams } from "./baseAdapter";
+import { Contract, uint256 } from "starknet";
+import erc20Abi from "@/data/erc20.abi.json";
+import { ERC20, TokenMarketData } from "@/modules";
+import { Protocols } from "@/interfaces";
+
+export interface UnusedBalanceAdapterConfig extends BaseAdapterConfig {}
+
+export class UnusedBalanceAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+  readonly config: UnusedBalanceAdapterConfig;
+  readonly tokenMarketData: TokenMarketData;
+
+  constructor(config: UnusedBalanceAdapterConfig) {
+    super(config, UnusedBalanceAdapter.name, Protocols.NONE);
+    this.config = config;
+    this.tokenMarketData = new TokenMarketData(this.config.pricer, this.config.networkConfig);
+  }
+
+  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: apy, type: isSupported ? APYType.LST : APYType.BASE };
+  }
+
+  protected async getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount> {
+    try {
+      const balance = await (new ERC20(this.config.networkConfig)).balanceOf(supportedPosition.asset.address, this.config.vaultAllocator.address, supportedPosition.asset.decimals);
+      return {
+        amount: balance,
+        remarks: "Unused balance"
+      }
+    } catch (_e) {
+      throw new Error(`${UnusedBalanceAdapter.name}: Failed to get position for ${supportedPosition.asset.symbol}`);
+    }
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    const baseToken = this.config.baseToken;
+    if (!amount) {
+      const infinite = new Web3Number('999999999999999999999999999', baseToken.decimals);
+      return {
+        tokenInfo: baseToken,
+        amount: infinite,
+        usdValue: Number.POSITIVE_INFINITY,
+        remarks: "Max deposit (infinity)",
+        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 usdValue = await this.getUSDValue(baseToken, current.amount);
+    return {
+      tokenInfo: baseToken,
+      amount: current.amount,
+      usdValue,
+      remarks: "Max withdraw",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol
+    };
+  }
+
+  protected _getDepositLeaf(): {
+    target: ContractAddr,
+    method: string,
+    packedArguments: bigint[];
+    sanitizer: ContractAddr,
+    id: string
+  }[] {
+    return [];
+  }
+
+  protected _getWithdrawLeaf(): {
+    target: ContractAddr,
+    method: string,
+    packedArguments: bigint[];
+    sanitizer: ContractAddr,
+    id: string
+  }[] {
+    return [];
+  }
+
+  async getHealthFactor(): Promise<number> {
+   return Promise.resolve(10);
+  }
+
+  getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+    return Promise.resolve([]);
+  }
+
+  getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+    return Promise.resolve([]);
+  }
+}
+
+