@strkfarm/sdk 1.0.55 → 1.0.56

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

@@ -0,0 +1,274 @@
+import { LeafData, logger  } from "@/utils"
+import { CairoCustomEnum, Contract, hash, num, RpcProvider, shortString, uint256, Uint256 } from "starknet";
+import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { AdapterLeafType, BaseAdapter, GenerateCallFn, ManageCall } from "./baseAdapter";
+import VesuSingletonAbi from '../../data/vesu-singleton.abi.json';
+import { IConfig, TokenInfo, VaultPosition } from "@/interfaces";
+import { PricerBase } from "@/modules/pricerBase";
+import VesuPoolIDs from "@/data/vesu_pools.json";
+import { getAPIUsingHeadlessBrowser } from "@/node/headless";
+import { Global } from "@/global";
+
+interface VesuPoolsInfo { pools: any[]; isErrorPoolsAPI: boolean };
+
+export enum VesuAmountType {
+  Delta,
+  Target
+}
+
+export enum VesuAmountDenomination {
+  Native,
+  Assets
+}
+
+export interface i257 {
+  abs: Web3Number,
+  is_negative: boolean,
+}
+
+export interface VesuAmount {
+  amount_type: VesuAmountType,
+  denomination: VesuAmountDenomination,
+  value: i257
+}
+
+export interface VesuModifyPositionCallParams {
+  collateralAmount: VesuAmount,
+  debtAmount: VesuAmount
+}
+
+export interface VesuAdapterConfig {
+  poolId: ContractAddr,
+  collateral: TokenInfo,
+  debt: TokenInfo,
+  vaultAllocator: ContractAddr,
+  id: string
+}
+
+export const VesuPools = {
+  Genesis: ContractAddr.from('0x4dc4f0ca6ea4961e4c8373265bfd5317678f4fe374d76f3fd7135f57763bf28')
+}
+
+export class VesuAdapter extends BaseAdapter {
+  VESU_SINGLETON = ContractAddr.from("0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160");
+  config: VesuAdapterConfig;
+  networkConfig: IConfig | undefined;
+  pricer: PricerBase | undefined;
+  cache: Record<string, any> = {};
+
+  constructor(config: VesuAdapterConfig) {
+    super();
+    this.config = config;
+  }
+
+  getModifyPosition = (): AdapterLeafType<VesuModifyPositionCallParams> => {
+    const positionData: bigint[] = [0n];
+    const packedArguments: bigint[] = [
+      toBigInt(this.config.poolId.toString()), // pool id
+      toBigInt(this.config.collateral.address.toString()), // collateral
+      toBigInt(this.config.debt.address.toString()), // debt
+      toBigInt(this.config.vaultAllocator.toString()), // vault allocator
+      toBigInt(positionData.length),
+      ...positionData
+    ];
+    const output = this.constructSimpleLeafData({
+      id: this.config.id,
+      target: this.VESU_SINGLETON,
+      method: 'modify_position',
+      packedArguments
+    });
+
+    return { leaf: output, callConstructor: this.getModifyPositionCall.bind(this) };
+  }
+
+  static getDefaultModifyPositionCallParams(params: {
+    collateralAmount: Web3Number,
+    isAddCollateral: boolean,
+    debtAmount: Web3Number,
+    isBorrow: boolean
+  }) {
+    return {
+        collateralAmount: {
+            amount_type: VesuAmountType.Delta,
+            denomination: VesuAmountDenomination.Assets,
+            value: {
+                abs: params.collateralAmount,
+                is_negative: !params.isAddCollateral
+            }
+        },
+        debtAmount: {
+            amount_type: VesuAmountType.Delta,
+            denomination: VesuAmountDenomination.Assets,
+            value: {
+                abs: params.debtAmount,
+                is_negative: !params.isBorrow
+            }
+        }
+    }
+  }
+
+  getModifyPositionCall = (params: VesuModifyPositionCallParams): ManageCall => {
+    // pub pool_id: felt252,
+    // pub collateral_asset: ContractAddress,
+    // pub debt_asset: ContractAddress,
+    // pub user: ContractAddress,
+    // pub collateral: Amount,
+    // pub debt: Amount,
+    // pub data: Span<felt252>,
+    const _collateral = {
+      amount_type: this.formatAmountTypeEnum(params.collateralAmount.amount_type),
+      denomination: this.formatAmountDenominationEnum(params.collateralAmount.denomination),
+      value: {
+        abs: uint256.bnToUint256(params.collateralAmount.value.abs.toWei()),
+        is_negative: params.collateralAmount.value.is_negative
+      }
+    };
+    const _debt = {
+      amount_type: this.formatAmountTypeEnum(params.debtAmount.amount_type),
+      denomination: this.formatAmountDenominationEnum(params.debtAmount.denomination),
+      value: {
+        abs: uint256.bnToUint256(params.debtAmount.value.abs.toWei()),
+        is_negative: params.debtAmount.value.is_negative
+      }
+    };
+    const singletonContract = new Contract(VesuSingletonAbi, this.VESU_SINGLETON.toString(), new RpcProvider({nodeUrl: ''}));
+    const call = singletonContract.populate('modify_position', {
+      params: {
+        pool_id: this.config.poolId.toBigInt(),
+        collateral_asset: this.config.collateral.address.toBigInt(),
+        debt_asset: this.config.debt.address.toBigInt(),
+        user: this.config.vaultAllocator.toBigInt(),
+        collateral: _collateral,
+        debt: _debt,
+        data: [0]
+      }
+    });
+    return {
+      sanitizer: SIMPLE_SANITIZER,
+      call: {
+        contractAddress: this.VESU_SINGLETON,
+        selector: hash.getSelectorFromName('modify_position'),
+        calldata: [
+          ...call.calldata as bigint[]
+        ]
+      }
+    }
+  }
+
+  formatAmountTypeEnum(amountType: VesuAmountType) {
+    switch(amountType) {
+      case VesuAmountType.Delta:
+        return new CairoCustomEnum({ Delta: {} });
+      case VesuAmountType.Target:
+        return new CairoCustomEnum({ Target: {} });
+    }
+    throw new Error(`Unknown VesuAmountType: ${amountType}`);
+  }
+
+  formatAmountDenominationEnum(denomination: VesuAmountDenomination) {
+    switch(denomination) {
+      case VesuAmountDenomination.Native:
+        return new CairoCustomEnum({ Native: {} });
+      case VesuAmountDenomination.Assets:
+        return new CairoCustomEnum({ Assets: {} });
+    }
+    throw new Error(`Unknown VesuAmountDenomination: ${denomination}`);
+  }
+
+  getVesuSingletonContract(config: IConfig) {
+    return new Contract(VesuSingletonAbi, this.VESU_SINGLETON.address, config.provider);
+  }
+
+  async getLTVConfig(config: IConfig) {
+    const CACHE_KEY = 'ltv_config';
+    if (this.cache[CACHE_KEY]) {
+      return this.cache[CACHE_KEY] as number;
+    }
+    const output: any = await this.getVesuSingletonContract(config)
+      .call('ltv_config', [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address])
+    this.cache[CACHE_KEY] = Number(output.max_ltv) / 1e18;
+    return this.cache[CACHE_KEY] as number;
+  }
+
+  async getPositions(config: IConfig): Promise<VaultPosition[]> {
+    if (!this.pricer) {
+      throw new Error('Pricer is not initialized');
+    }
+    //  { '0': { collateral_shares: 0n, nominal_debt: 0n }, '1': 0n, '2': 0n }
+    const CACHE_KEY = 'positions';
+    if (this.cache[CACHE_KEY]) {
+      return this.cache[CACHE_KEY];
+    }
+    const output: any = await this.getVesuSingletonContract(config)
+      .call('position_unsafe', [
+        this.config.poolId.address,
+        this.config.collateral.address.address,
+        this.config.debt.address.address,
+        this.config.vaultAllocator.address
+      ]);
+
+    const token1Price = await this.pricer.getPrice(this.config.collateral.symbol);
+    const token2Price = await this.pricer.getPrice(this.config.debt.symbol);
+
+    const collateralAmount = Web3Number.fromWei(output['1'].toString(), this.config.collateral.decimals);
+    const debtAmount = Web3Number.fromWei(output['2'].toString(), this.config.debt.decimals);
+    const value = [{
+      amount: collateralAmount,
+      token: this.config.collateral,
+      usdValue: collateralAmount.multipliedBy(token1Price.price).toNumber(),
+      remarks: "Collateral"
+    }, {
+      amount: debtAmount,
+      token: this.config.debt,
+      usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
+      remarks: "Debt"
+    }];
+    this.cache[CACHE_KEY] = value;
+    return value;
+  }
+
+  static async getVesuPools(
+      retry = 0
+    ): Promise<VesuPoolsInfo> {
+      const CACHE_KEY = 'VESU_POOLS';
+      const cacheValue = Global.getGlobalCache<VesuPoolsInfo>(CACHE_KEY);
+      if (cacheValue) {
+        return cacheValue;
+      }
+
+      let isErrorPoolsAPI = false;
+      let pools: any[] = [];
+      try {
+        const data = await getAPIUsingHeadlessBrowser(
+          "https://api.vesu.xyz/pools"
+        );
+        pools = data.data;
+
+        // Vesu API is unstable sometimes, some Pools may be missing sometimes
+        for (const pool of VesuPoolIDs.data) {
+          const found = pools.find((d: any) => d.id === pool.id);
+          if (!found) {
+            logger.verbose(`VesuRebalance: pools: ${JSON.stringify(pools)}`);
+            logger.verbose(
+              `VesuRebalance: Pool ${pool.id} not found in Vesu API, using hardcoded data`
+            );
+            throw new Error(`pool not found [sanity check]: ${pool.id}`);
+          }
+        }
+      } catch (e) {
+        logger.error(
+          `${VesuAdapter.name}: Error fetching pools for retry ${retry}`,
+          e
+        );
+        isErrorPoolsAPI = true;
+        if (retry < 10) {
+          await new Promise((resolve) => setTimeout(resolve, 5000 * (retry + 1)));
+          return await this.getVesuPools(retry + 1);
+        }
+      }
+
+      Global.setGlobalCache(CACHE_KEY, { pools, isErrorPoolsAPI }, 300000); // cache for 5 minutes
+      return { pools, isErrorPoolsAPI };
+  }
+}