@gearbox-protocol/sdk 3.0.0-vfourabi.1 → 3.0.0-vfourabi.3

package/src/sdk/market/pricefeeds/YearnPriceFeed.ts

@@ -0,0 +1,24 @@
+import { iyVaultAbi, yearnPriceFeedAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { AbstractLPPriceFeedContract } from "./AbstractLPPriceFeed";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+
+type abi = typeof yearnPriceFeedAbi;
+
+export class YearnPriceFeedContract extends AbstractLPPriceFeedContract<abi> {
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, {
+      ...args,
+      name: "YearnPriceFeed",
+      abi: yearnPriceFeedAbi,
+    });
+  }
+
+  public override async getValue(): Promise<bigint> {
+    return await this.sdk.provider.publicClient.readContract({
+      abi: iyVaultAbi,
+      address: this.lpContract,
+      functionName: "pricePerShare",
+    });
+  }
+}

package/src/sdk/market/pricefeeds/ZeroPriceFeed.ts

@@ -0,0 +1,17 @@
+import { zeroPriceFeedAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+import { AbstractPriceFeedContract } from "./AbstractPriceFeed";
+
+type abi = typeof zeroPriceFeedAbi;
+
+export class ZeroPriceFeedContract extends AbstractPriceFeedContract<abi> {
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, {
+      ...args,
+      name: "ZeroPriceFeed",
+      abi: zeroPriceFeedAbi,
+      decimals: 8,
+    });
+  }
+}

package/src/sdk/market/pricefeeds/index.ts

@@ -0,0 +1,20 @@
+export * from "./AbstractPriceFeed";
+export * from "./BalancerStablePriceFeed";
+export * from "./BalancerWeightedPriceFeed";
+export * from "./BoundedPriceFeed";
+export * from "./ChainlinkPriceFeed";
+export * from "./CompositePriceFeed";
+export * from "./CurveCryptoPriceFeed";
+export * from "./CurveStablePriceFeed";
+export * from "./CurveUSDPriceFeed";
+export * from "./Erc4626PriceFeed";
+export * from "./MellowLRTPriceFeed";
+export * from "./PendleTWAPPTPriceFeed";
+export * from "./PriceFeedRef";
+export * from "./PriceFeedsRegister";
+export * from "./RedstonePriceFeed";
+export * from "./types";
+export * from "./utils";
+export * from "./WstETHPriceFeed";
+export * from "./YearnPriceFeed";
+export * from "./ZeroPriceFeed";

package/src/sdk/market/pricefeeds/types.ts

@@ -0,0 +1,82 @@
+import type { UnionOmit } from "viem";
+
+import type { IBaseContract } from "../../base";
+import type { PriceFeedStateHuman, RawTx } from "../../types";
+import type { PriceFeedRef } from "./PriceFeedRef";
+
+export type PriceFeedUsageType = "Main" | "Reserve";
+
+export type PriceFeedContractTypeLegacy =
+  | "PF_CHAINLINK_ORACLE"
+  | "PF_ZERO_ORACLE"
+  | "PF_COMPOSITE_ORACLE"
+  | "PF_BALANCER_STABLE_LP_ORACLE"
+  | "PF_CURVE_STABLE_LP_ORACLE"
+  | "PF_CURVE_CRYPTO_LP_ORACLE"
+  | "PF_CURVE_USD_ORACLE"
+  | "PF_ERC4626_ORACLE"
+  | "PF_WSTETH_ORACLE"
+  | "PF_YEARN_ORACLE"
+  | "PF_MELLOW_LRT_ORACLE"
+  | "PF_BALANCER_WEIGHTED_LP_ORACLE"
+  | "PF_BOUNDED_ORACLE"
+  | "PF_PYTH_ORACLE"
+  | "PF_REDSTONE_ORACLE"
+  | "PF_PENDLE_PT_TWAP_ORACLE";
+
+export type PriceFeedContractType =
+  | "PRICE_FEED::EXTERNAL"
+  | "PRICE_FEED::ZERO"
+  | "PRICE_FEED::COMPOSITE"
+  | "PRICE_FEED::BALANCER_STABLE"
+  | "PRICE_FEED::CURVE_STABLE"
+  | "PRICE_FEED::CURVE_CRYPTO"
+  | "PRICE_FEED::CURVE_USD"
+  | "PRICE_FEED::ERC4626"
+  | "PRICE_FEED::WSTETH"
+  | "PRICE_FEED::YEARN"
+  | "PRICE_FEED::MELLOW_LRT"
+  | "PRICE_FEED::BALANCER_WEIGHTED"
+  | "PRICE_FEED::BOUNDED"
+  | "PRICE_FEED::PYTH"
+  | "PRICE_FEED::REDSTONE"
+  | "PRICE_FEED::PENDLE_PT_TWAP";
+
+export interface IPriceFeedContract extends IBaseContract {
+  readonly hasLowerBoundCap: boolean;
+  readonly priceFeedType: PriceFeedContractType;
+  readonly decimals: number;
+  /**
+   * True if the contract deployed at this address implements IUpdatablePriceFeed interface
+   */
+  readonly updatable: boolean;
+  /**
+   * It's possible to create PriceFeed with base params only.
+   * This flag idicates that all the price feed data (decimals, skip check, dependencies...) has been loaded from compressor
+   */
+  readonly loaded: boolean;
+
+  readonly underlyingPriceFeeds: readonly PriceFeedRef[];
+
+  answer: (overrides?: { blockNumber?: bigint }) => Promise<bigint>;
+  stateHuman: (
+    raw?: boolean,
+  ) => UnionOmit<PriceFeedStateHuman, "stalenessPeriod">;
+
+  /**
+   * Returns all updatable depenedencies (uderlying price feeds) of this price feed, including price feed itself, if it's updatable
+   * @returns
+   */
+  updatableDependencies: () => IPriceFeedContract[];
+}
+
+export interface ILPPriceFeedContract extends IPriceFeedContract {
+  getValue: () => Promise<bigint>;
+  getLowerBound: () => Promise<bigint>;
+  currentLowerBound: () => Promise<bigint>;
+}
+
+export interface UpdatePriceFeedsResult {
+  txs: RawTx[];
+  timestamp: number;
+}

package/src/sdk/market/pricefeeds/utils.ts

@@ -0,0 +1,24 @@
+import { decodeFunctionData } from "viem";
+
+import { iUpdatablePriceFeedAbi } from "../../../abi/iUpdatablePriceFeed";
+import type { RawTx } from "../../types";
+
+/**
+ * Helper method to convert our RawTx into viem's multicall format
+ * Involves decoding what was previously encoded, but it's better than adding another method to PriceOracle
+ * @param tx
+ * @returns
+ */
+export function rawTxToMulticallPriceUpdate(tx: RawTx) {
+  const { to, callData } = tx;
+  const { args, functionName } = decodeFunctionData({
+    abi: iUpdatablePriceFeedAbi,
+    data: callData,
+  });
+  return {
+    abi: iUpdatablePriceFeedAbi,
+    address: to,
+    functionName,
+    args,
+  };
+}

package/src/sdk/plugins/index.ts

@@ -0,0 +1,10 @@
+import type { BaseState, IBaseContract } from "../base";
+import type { GearboxSDK } from "../GearboxSDK";
+
+export interface IGearboxSDKPlugin {
+  name: string;
+  createContract: (
+    sdk: GearboxSDK,
+    params: BaseState,
+  ) => IBaseContract | undefined;
+}

package/src/sdk/router/PathOptionFactory.ts

@@ -0,0 +1,147 @@
+import type { Address } from "viem";
+
+import type { NetworkType } from "../chain";
+import type {
+  AuraLPToken,
+  AuraStakedToken,
+  BalancerLPToken,
+  ConvexLPToken,
+  CurveLPToken,
+  YearnLPToken,
+} from "../sdk-gov-legacy";
+import {
+  auraTokens,
+  balancerLpTokens,
+  contractParams,
+  convexTokens,
+  curveTokens,
+  getTokenSymbol,
+  isBalancerLPToken,
+  isCurveLPToken,
+  tokenDataByNetwork,
+  yearnTokens,
+} from "../sdk-gov-legacy";
+import type { Asset, PathOptionSerie } from "./types";
+
+export class PathOptionFactory {
+  // TODO: get rid of token data from SDK
+  static generatePathOptions(
+    balances: readonly Asset[],
+    network: NetworkType,
+    loopsInTx: number,
+  ): PathOptionSerie[] {
+    const curvePools = PathOptionFactory.getCurvePools(balances);
+    const balancerPools = PathOptionFactory.getBalancerPools(balances);
+
+    const curveInitPO: PathOptionSerie = curvePools.map(symbol => {
+      return {
+        target: tokenDataByNetwork[network][symbol],
+        option: 0,
+        totalOptions: contractParams[curveTokens[symbol].pool].tokens.length,
+      };
+    });
+    const balancerInitPO: PathOptionSerie = balancerPools.map(symbol => {
+      return {
+        target: tokenDataByNetwork[network][symbol],
+        option: 0,
+        totalOptions: balancerLpTokens[symbol].underlying.length,
+      };
+    });
+    const initPO = [...curveInitPO, ...balancerInitPO];
+
+    const totalLoops = initPO.reduce<number>(
+      (acc, item) => acc * item.totalOptions,
+      1,
+    );
+
+    const result: PathOptionSerie[] = [];
+
+    let currentPo = [...initPO];
+
+    for (let i = 0; i < totalLoops; i++) {
+      if (i % loopsInTx === 0) {
+        result.push(currentPo);
+      }
+      if (i < totalLoops - 1) {
+        currentPo = PathOptionFactory.next(currentPo);
+      }
+    }
+
+    return result;
+  }
+
+  static getCurvePools(balances: readonly Asset[]): CurveLPToken[] {
+    const nonZeroBalances = balances.filter(b => b.balance > 1n);
+
+    const curvePools = nonZeroBalances
+      .map(b => getTokenSymbol(b.token))
+      .filter(symbol => isCurveLPToken(symbol)) as CurveLPToken[];
+
+    const yearnCurveTokens = Object.entries(yearnTokens)
+      .filter(([, data]) => isCurveLPToken(data.underlying))
+      .map(([token]) => token);
+
+    const curvePoolsFromYearn = nonZeroBalances
+      .map(b => getTokenSymbol(b.token)!)
+      .filter(symbol => yearnCurveTokens.includes(symbol))
+      .map(
+        symbol => yearnTokens[symbol as YearnLPToken].underlying,
+      ) as CurveLPToken[];
+
+    const convexCurveTokens = Object.entries(convexTokens)
+      .filter(([, data]) => isCurveLPToken(data.underlying))
+      .map(([token]) => token);
+
+    const curvePoolsFromConvex = nonZeroBalances
+      .map(b => getTokenSymbol(b.token)!)
+      .filter(symbol => convexCurveTokens.includes(symbol))
+      .map(symbol => convexTokens[symbol as ConvexLPToken].underlying);
+
+    const curveSet = new Set([
+      ...curvePools,
+      ...curvePoolsFromYearn,
+      ...curvePoolsFromConvex,
+    ]);
+    return Array.from(curveSet.values());
+  }
+
+  static getBalancerPools(balances: readonly Asset[]): BalancerLPToken[] {
+    const nonZeroBalances = Object.entries(balances).filter(
+      ([, balance]) => balance.balance > 1,
+    );
+
+    const balancerPools = nonZeroBalances
+      .map(([token]) => getTokenSymbol(token as Address)!)
+      .filter(symbol => isBalancerLPToken(symbol)) as BalancerLPToken[];
+
+    const balancerAuraTokens = Object.entries(auraTokens)
+      .filter(([, data]) => isBalancerLPToken(data.underlying))
+      .map(([token]) => token);
+
+    const balancerTokensFromAura = nonZeroBalances
+      .map(([token]) => getTokenSymbol(token as Address)!)
+      .filter(symbol => balancerAuraTokens.includes(symbol))
+      .map(
+        symbol =>
+          auraTokens[symbol as AuraLPToken | AuraStakedToken].underlying,
+      );
+
+    const balancerSet = new Set([...balancerPools, ...balancerTokensFromAura]);
+
+    return Array.from(balancerSet.values());
+  }
+
+  static next(path: PathOptionSerie): PathOptionSerie {
+    let newPath = [...path];
+    for (let i = path.length - 1; i >= 0; i--) {
+      const po = { ...newPath[i] };
+      po.option++;
+      newPath[i] = po;
+
+      if (po.option < po.totalOptions) return newPath;
+      po.option = 0;
+    }
+
+    throw new Error("Path options overflow");
+  }
+}