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

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

@@ -0,0 +1,137 @@
+import type { Abi, RequiredBy, UnionOmit } from "viem";
+
+import { ilpPriceFeedAbi } from "../../abi";
+import type { PriceFeedTreeNode } from "../../base";
+import { BaseContract } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PriceFeedStateHuman } from "../../types";
+import { PriceFeedRef } from "./PriceFeedRef";
+import type { IPriceFeedContract, PriceFeedContractType } from "./types";
+
+export type PartialPriceFeedTreeNode = RequiredBy<
+  Partial<PriceFeedTreeNode>,
+  "baseParams"
+>;
+
+export type PriceFeedConstructorArgs<abi extends Abi | readonly unknown[]> =
+  PartialPriceFeedTreeNode & {
+    abi: abi;
+    name: string;
+  };
+
+export abstract class AbstractPriceFeedContract<
+    const abi extends Abi | readonly unknown[],
+  >
+  extends BaseContract<abi>
+  implements IPriceFeedContract
+{
+  /**
+   * True if the contract deployed at this address implements IUpdatablePriceFeed interface
+   */
+  #updatable?: boolean;
+  #decimals?: number;
+  #underlyingPriceFeeds?: readonly PriceFeedRef[];
+  #skipCheck?: boolean;
+
+  public hasLowerBoundCap = false;
+  public readonly description?: string;
+
+  constructor(sdk: GearboxSDK, args: PriceFeedConstructorArgs<abi>) {
+    super(sdk, {
+      abi: args.abi,
+      addr: args.baseParams.addr,
+      name: args.name + (args.description ? ` ${args.description}` : ""),
+      contractType: args.baseParams.contractType,
+      version: args.baseParams.version,
+    });
+    this.description = args.description;
+    this.#decimals = args.decimals;
+    this.#updatable = args.updatable;
+    this.#skipCheck = args.skipCheck;
+
+    if (args.underlyingFeeds && args.underlyingStalenessPeriods) {
+      this.#underlyingPriceFeeds = args.underlyingFeeds.map(
+        (address, i) =>
+          new PriceFeedRef(
+            this.sdk,
+            address,
+            args.underlyingStalenessPeriods![i],
+          ),
+      );
+    }
+  }
+
+  public get loaded(): boolean {
+    return this.#decimals !== undefined;
+  }
+
+  public get decimals(): number {
+    if (this.#decimals === undefined) {
+      throw new Error("price feed has been initialized with BaseParams only");
+    }
+    return this.#decimals;
+  }
+
+  public get updatable(): boolean {
+    if (this.#updatable === undefined) {
+      throw new Error("price feed has been initialized with BaseParams only");
+    }
+    return this.#updatable;
+  }
+
+  public get skipCheck(): boolean {
+    if (this.#skipCheck === undefined) {
+      throw new Error("price feed has been initialized with BaseParams only");
+    }
+    return this.#skipCheck;
+  }
+
+  public get underlyingPriceFeeds(): readonly PriceFeedRef[] {
+    if (!this.#underlyingPriceFeeds) {
+      throw new Error("price feed has been initialized with BaseParams only");
+    }
+    return this.#underlyingPriceFeeds;
+  }
+
+  public get priceFeedType(): PriceFeedContractType {
+    return this.contractType as PriceFeedContractType;
+  }
+
+  public override stateHuman(
+    raw = true,
+  ): UnionOmit<PriceFeedStateHuman, "stalenessPeriod"> {
+    return {
+      ...super.stateHuman(raw),
+      description: this.description,
+      contractType: this.priceFeedType,
+      skipCheck: this.skipCheck,
+      pricefeeds: this.underlyingPriceFeeds.map(f => f.stateHuman(raw)),
+    };
+  }
+
+  async currentLowerBound(): Promise<bigint> {
+    return await this.sdk.provider.publicClient.readContract({
+      abi: ilpPriceFeedAbi,
+      address: this.address,
+      functionName: "lowerBound",
+    });
+  }
+
+  async answer(overrides?: { blockNumber?: bigint }): Promise<bigint> {
+    const lastRoundData = await this.sdk.provider.publicClient.readContract({
+      abi: ilpPriceFeedAbi,
+      address: this.address,
+      functionName: "latestRoundData",
+      ...overrides,
+    });
+
+    return lastRoundData[1];
+  }
+
+  public updatableDependencies(): IPriceFeedContract[] {
+    const underlying = this.underlyingPriceFeeds.flatMap(f =>
+      f.priceFeed.updatableDependencies(),
+    );
+    return this.updatable ? [this, ...underlying] : underlying;
+  }
+}

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

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

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

@@ -0,0 +1,70 @@
+import type { Address, Hex, UnionOmit } from "viem";
+import { decodeAbiParameters, hexToBytes } from "viem";
+
+import { bptWeightedPriceFeedAbi, iBalancerWeightedPoolAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { BalancerWeightedPriceFeedStateHuman } from "../../types/state-human";
+import { AbstractLPPriceFeedContract } from "./AbstractLPPriceFeed";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+
+type abi = typeof bptWeightedPriceFeedAbi;
+
+export class BalancerWeightedPriceFeedContract extends AbstractLPPriceFeedContract<abi> {
+  public readonly vault: Address;
+  public readonly poolId: Hex;
+  public readonly weights: readonly [
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+  ];
+
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    const decoded = decodeAbiParameters(
+      [
+        { type: "bytes", name: "superParams" },
+        { type: "address", name: "vault" },
+        { type: "bytes32", name: "poolId" },
+        { type: "uint256[8]", name: "weights" },
+      ],
+      hexToBytes(args.baseParams.serializedParams),
+    );
+
+    super(sdk, {
+      ...args,
+      baseParams: {
+        ...args.baseParams,
+        serializedParams: decoded[0],
+      },
+      name: "BalancerWeighedPriceFeed",
+      abi: bptWeightedPriceFeedAbi,
+    });
+    this.vault = decoded[1];
+    this.poolId = decoded[2];
+    this.weights = decoded[3];
+  }
+
+  public override async getValue(): Promise<bigint> {
+    return await this.sdk.provider.publicClient.readContract({
+      abi: iBalancerWeightedPoolAbi,
+      address: this.lpContract,
+      functionName: "getRate",
+    });
+  }
+
+  public override stateHuman(
+    raw?: boolean,
+  ): UnionOmit<BalancerWeightedPriceFeedStateHuman, "stalenessPeriod"> {
+    return {
+      ...super.stateHuman(raw),
+      contractType: "PRICE_FEED::BALANCER_WEIGHTED",
+      vault: this.vault,
+      poolId: this.poolId,
+      weights: [...this.weights],
+    };
+  }
+}

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

@@ -0,0 +1,34 @@
+import { decodeAbiParameters } from "viem";
+
+import { boundedPriceFeedAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { BoundedOracleStateHuman } from "../../types";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+import { AbstractPriceFeedContract } from "./AbstractPriceFeed";
+
+type abi = typeof boundedPriceFeedAbi;
+
+export class BoundedPriceFeedContract extends AbstractPriceFeedContract<abi> {
+  public readonly upperBound: bigint;
+
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, { ...args, name: "BoundedPriceFeed", abi: boundedPriceFeedAbi });
+    const decoder = decodeAbiParameters(
+      [
+        { type: "int256" }, //  upperBound
+      ],
+      args.baseParams.serializedParams,
+    );
+    this.upperBound = decoder[0];
+  }
+
+  public override stateHuman(
+    raw = true,
+  ): Omit<BoundedOracleStateHuman, "stalenessPeriod"> {
+    return {
+      ...super.stateHuman(raw),
+      contractType: "PRICE_FEED::BOUNDED",
+      upperBound: this.upperBound,
+    };
+  }
+}

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

@@ -0,0 +1,16 @@
+import { chainlinkReadableAggregatorAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+import { AbstractPriceFeedContract } from "./AbstractPriceFeed";
+
+type abi = typeof chainlinkReadableAggregatorAbi;
+
+export class ChainlinkPriceFeedContract extends AbstractPriceFeedContract<abi> {
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, {
+      ...args,
+      name: "ChainlinkPriceFeed",
+      abi: chainlinkReadableAggregatorAbi,
+    });
+  }
+}

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

@@ -0,0 +1,25 @@
+import { compositePriceFeedAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+import { AbstractPriceFeedContract } from "./AbstractPriceFeed";
+import type { PriceFeedRef } from "./PriceFeedRef";
+
+type abi = typeof compositePriceFeedAbi;
+
+export class CompositePriceFeedContract extends AbstractPriceFeedContract<abi> {
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, {
+      ...args,
+      name: "CompositePriceFeed",
+      abi: compositePriceFeedAbi,
+    });
+  }
+
+  public get targetToBasePriceFeed(): PriceFeedRef {
+    return this.underlyingPriceFeeds[0];
+  }
+
+  public get baseToUsdPriceFeed(): PriceFeedRef {
+    return this.underlyingPriceFeeds[1];
+  }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,36 @@
+import { erc4626Abi } from "viem";
+
+import { ierc20Abi } from "../../../abi/iERC20";
+import { erc4626PriceFeedAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { AbstractLPPriceFeedContract } from "./AbstractLPPriceFeed";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+
+type abi = typeof erc4626PriceFeedAbi;
+
+export class Erc4626PriceFeedContract extends AbstractLPPriceFeedContract<abi> {
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, {
+      ...args,
+      name: "ERC4626PriceFeed",
+      abi: erc4626PriceFeedAbi,
+    });
+  }
+
+  public override async getValue(): Promise<bigint> {
+    const decimals = await this.sdk.provider.publicClient.readContract({
+      abi: ierc20Abi,
+      address: this.lpContract,
+      functionName: "decimals",
+    });
+
+    const price = await this.sdk.provider.publicClient.readContract({
+      abi: erc4626Abi,
+      address: this.lpContract,
+      functionName: "convertToAssets",
+      args: [10n ** BigInt(decimals)],
+    });
+
+    return price;
+  }
+}

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

@@ -0,0 +1,26 @@
+import { iMellowVaultAbi, mellowLrtPriceFeedAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { AbstractLPPriceFeedContract } from "./AbstractLPPriceFeed";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+
+type abi = typeof mellowLrtPriceFeedAbi;
+
+export class MellowLRTPriceFeedContract extends AbstractLPPriceFeedContract<abi> {
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, {
+      ...args,
+      name: "MellowLRTPriceFeed",
+      abi: mellowLrtPriceFeedAbi,
+    });
+  }
+
+  public override async getValue(): Promise<bigint> {
+    const stack = await this.sdk.provider.publicClient.readContract({
+      abi: iMellowVaultAbi,
+      address: this.lpContract,
+      functionName: "calculateStack",
+    });
+
+    return (stack.totalValue * BigInt(1e18)) / stack.totalSupply;
+  }
+}

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

@@ -0,0 +1,44 @@
+import type { Address } from "viem";
+import { decodeAbiParameters } from "viem";
+
+import { pendleTWAPPTPriceFeedAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+import { AbstractPriceFeedContract } from "./AbstractPriceFeed";
+
+const abi = pendleTWAPPTPriceFeedAbi;
+type abi = typeof abi;
+
+export class PendleTWAPPTPriceFeed extends AbstractPriceFeedContract<abi> {
+  public readonly market: Address;
+  public readonly sy: Address;
+  public readonly yt: Address;
+  public readonly expiry: bigint;
+  public readonly twapWindow: number;
+  public readonly priceToSy: boolean;
+
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, {
+      ...args,
+      name: "PendleTWAPPTPriceFeed",
+      abi,
+    });
+    const decoded = decodeAbiParameters(
+      [
+        { type: "address", name: "market" },
+        { type: "address", name: "sy" },
+        { type: "address", name: "yt" },
+        { type: "uint256", name: "expiry" },
+        { type: "uint32", name: "twapWindow" },
+        { type: "bool", name: "priceToSy" },
+      ],
+      args.baseParams.serializedParams,
+    );
+    this.market = decoded[0];
+    this.sy = decoded[1];
+    this.yt = decoded[2];
+    this.expiry = decoded[3];
+    this.twapWindow = decoded[4];
+    this.priceToSy = decoded[5];
+  }
+}

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

@@ -0,0 +1,34 @@
+import type { Address } from "viem";
+
+import { SDKConstruct } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PriceFeedStateHuman } from "../../types";
+import { formatDuration } from "../../utils";
+import type { IPriceFeedContract } from "./types";
+
+export class PriceFeedRef extends SDKConstruct {
+  public readonly address: Address;
+  public readonly stalenessPeriod: number;
+
+  #priceFeed?: IPriceFeedContract;
+
+  constructor(sdk: GearboxSDK, address: Address, stalenessPeriod: number) {
+    super(sdk);
+    this.address = address;
+    this.stalenessPeriod = stalenessPeriod;
+  }
+
+  public get priceFeed(): IPriceFeedContract {
+    if (!this.#priceFeed) {
+      this.#priceFeed = this.sdk.priceFeeds.mustGet(this.address);
+    }
+    return this.#priceFeed;
+  }
+
+  public stateHuman(raw = true): PriceFeedStateHuman {
+    return {
+      ...this.priceFeed.stateHuman(raw),
+      stalenessPeriod: formatDuration(this.stalenessPeriod),
+    };
+  }
+}