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

package/src/sdk/market/credit/CreditManagerV310Contract.ts

@@ -0,0 +1,122 @@
+import type { Address, ContractEventName, Log } from "viem";
+
+import { iCreditManagerV310Abi } from "../../../abi/v310";
+import type { CreditManagerData, CreditManagerState } from "../../base";
+import { BaseContract } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { CreditManagerStateHuman } from "../../types";
+import { AddressMap, fmtBinaryMask, percentFmt } from "../../utils";
+import type { IAdapterContract } from "../adapters";
+import { createAdapter } from "../adapters";
+import type { ICreditManagerContract } from "./types";
+
+const abi = iCreditManagerV310Abi;
+type abi = typeof iCreditManagerV310Abi;
+
+// Augmenting contract class with interface of compressor data object
+export interface CreditManagerV310Contract
+  extends Omit<
+      CreditManagerState,
+      "baseParams" | "collateralTokens" | "liquidationThresholds"
+    >,
+    BaseContract<abi> {}
+
+export class CreditManagerV310Contract
+  extends BaseContract<abi>
+  implements ICreditManagerContract
+{
+  /**
+   * Mapping targetContract => adapter
+   */
+  public readonly adapters: AddressMap<IAdapterContract>;
+  /**
+   * Mapping token address => liquidation threshold
+   */
+  public readonly liquidationThresholds: AddressMap<number>;
+
+  constructor(sdk: GearboxSDK, { creditManager, adapters }: CreditManagerData) {
+    const { baseParams, collateralTokens, ...rest } = creditManager;
+    super(sdk, {
+      ...baseParams,
+      name: `CreditManagerV310(${creditManager.name})`,
+      abi,
+    });
+    Object.assign(this, rest);
+    this.liquidationThresholds = new AddressMap(
+      collateralTokens.map(ct => [ct.token, ct.liquidationThreshold]),
+      "liquidationThresholds",
+    );
+
+    this.adapters = new AddressMap(undefined, "adapters");
+    for (const adapterData of adapters) {
+      try {
+        const adapter = createAdapter(this.sdk, adapterData);
+        adapter.name = `${adapter.name}(${this.name})`;
+        this.adapters.upsert(adapter.targetContract, adapter);
+      } catch (e) {
+        throw new Error(`cannot attach adapter: ${e}`, { cause: e });
+      }
+    }
+  }
+
+  public override stateHuman(raw?: boolean): CreditManagerStateHuman {
+    return {
+      ...super.stateHuman(raw),
+      name: this.name,
+      accountFactory: this.labelAddress(this.accountFactory),
+      underlying: this.labelAddress(this.underlying),
+      pool: this.labelAddress(this.pool),
+      creditFacade: this.labelAddress(this.creditFacade),
+      creditConfigurator: this.labelAddress(this.creditConfigurator),
+      maxEnabledTokens: this.maxEnabledTokens,
+      collateralTokens: Object.fromEntries(
+        this.liquidationThresholds
+          .entries()
+          .map(([k, v]) => [
+            this.labelAddress(k as Address),
+            percentFmt(v, raw),
+          ]),
+      ) as Record<Address, string>,
+      feeInterest: percentFmt(this.feeInterest, raw),
+      feeLiquidation: percentFmt(this.feeLiquidation, raw),
+      liquidationDiscount: percentFmt(this.liquidationDiscount, raw),
+      feeLiquidationExpired: percentFmt(this.feeLiquidationExpired, raw),
+      liquidationDiscountExpired: percentFmt(
+        this.liquidationDiscountExpired,
+        raw,
+      ),
+      quotedTokensMask: fmtBinaryMask(0n), // TODO: ?
+      contractsToAdapters: Object.fromEntries(
+        this.adapters
+          .entries()
+          .map(([k, v]) => [
+            this.labelAddress(k),
+            this.labelAddress(v.address),
+          ]),
+      ),
+      creditAccounts: [], // TODO: ?
+    };
+  }
+
+  public get collateralTokens(): Address[] {
+    return this.liquidationThresholds.keys();
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "SetCreditConfigurator":
+        this.dirty = true;
+        break;
+    }
+  }
+}

package/src/sdk/market/credit/CreditSuite.ts

@@ -0,0 +1,65 @@
+import type { Address } from "viem";
+
+import { type MarketData, SDKConstruct } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { CreditSuiteStateHuman, TVL } from "../../types";
+import createCreditConfigurator from "./createCreditConfigurator";
+import createCreditFacade from "./createCreditFacade";
+import createCreditManager from "./createCreditManager";
+import type {
+  CreditFacadeContract,
+  ICreditConfiguratorContract,
+  ICreditManagerContract,
+} from "./types";
+
+export class CreditSuite extends SDKConstruct {
+  public readonly name: string;
+  public readonly pool: Address;
+  public readonly underlying: Address;
+
+  public readonly creditManager: ICreditManagerContract;
+  public readonly creditFacade: CreditFacadeContract;
+  public readonly creditConfigurator: ICreditConfiguratorContract;
+
+  constructor(sdk: GearboxSDK, marketData: MarketData, index: number) {
+    super(sdk);
+    const { creditManagers, pool } = marketData;
+    const creditManager = creditManagers[index];
+    const { name } = creditManager.creditManager;
+
+    this.name = name;
+    this.pool = pool.baseParams.addr;
+    this.underlying = pool.underlying;
+
+    this.creditManager = createCreditManager(sdk, creditManager);
+    this.creditFacade = createCreditFacade(sdk, creditManager);
+    this.creditConfigurator = createCreditConfigurator(sdk, creditManager);
+  }
+
+  async tvl(): Promise<TVL> {
+    // const cas =
+    //   await this.service.peripheryFactory.dataCompressorV3Contract.getCreditsAccountByCreditManager(
+    //     this.creditManager.address,
+    //   );
+    const tvl = 0n; // cas.reduce((acc, ca) => acc + BigInt(ca.totalValue), 0n);
+    const tvlUSD = 0n; // cas.reduce((acc, ca) => acc + BigInt(ca.totalValueUSD), 0n);
+    return { tvl, tvlUSD };
+  }
+
+  override get dirty(): boolean {
+    // TODO: any other ways to get dirty, adapters maybe?
+    return (
+      this.creditFacade.dirty ||
+      this.creditManager.dirty ||
+      this.creditConfigurator.dirty
+    );
+  }
+
+  public stateHuman(raw = true): CreditSuiteStateHuman {
+    return {
+      creditFacade: this.creditFacade.stateHuman(raw),
+      creditManager: this.creditManager.stateHuman(raw),
+      creditConfigurator: this.creditConfigurator.stateHuman(raw),
+    };
+  }
+}

package/src/sdk/market/credit/createCreditConfigurator.ts

@@ -0,0 +1,18 @@
+import type { CreditManagerData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { CreditConfiguratorV300Contract } from "./CreditConfiguratorV300Contract";
+import { CreditConfiguratorV310Contract } from "./CreditConfiguratorV310Contract";
+import type { ICreditConfiguratorContract } from "./types";
+
+export default function createCreditConfigurator(
+  sdk: GearboxSDK,
+  data: CreditManagerData,
+): ICreditConfiguratorContract {
+  const v = data.creditConfigurator.baseParams.version;
+  if (v >= 300 && v < 310) {
+    return new CreditConfiguratorV300Contract(sdk, data);
+  } else if (v === 310n) {
+    return new CreditConfiguratorV310Contract(sdk, data);
+  }
+  throw new Error(`Unsupported credit configurator version: ${v}`);
+}

package/src/sdk/market/credit/createCreditFacade.ts

@@ -0,0 +1,18 @@
+import type { CreditManagerData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { CreditFacadeV300Contract } from "./CreditFacadeV300Contract";
+import { CreditFacadeV310Contract } from "./CreditFacadeV310Contract";
+import type { CreditFacadeContract } from "./types";
+
+export default function createCreditFacade(
+  sdk: GearboxSDK,
+  data: CreditManagerData,
+): CreditFacadeContract {
+  const v = data.creditFacade.baseParams.version;
+  if (v >= 300 && v < 310) {
+    return new CreditFacadeV300Contract(sdk, data);
+  } else if (v === 310n) {
+    return new CreditFacadeV310Contract(sdk, data);
+  }
+  throw new Error(`Unsupported credit facade version: ${v}`);
+}

package/src/sdk/market/credit/createCreditManager.ts

@@ -0,0 +1,18 @@
+import type { CreditManagerData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { CreditManagerV300Contract } from "./CreditManagerV300Contract";
+import { CreditManagerV310Contract } from "./CreditManagerV310Contract";
+import type { ICreditManagerContract } from "./types";
+
+export default function createCreditManager(
+  sdk: GearboxSDK,
+  data: CreditManagerData,
+): ICreditManagerContract {
+  const v = data.creditManager.baseParams.version;
+  if (v >= 300 && v < 310) {
+    return new CreditManagerV300Contract(sdk, data);
+  } else if (v === 310n) {
+    return new CreditManagerV310Contract(sdk, data);
+  }
+  throw new Error(`Unsupported credit manager version: ${v}`);
+}

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

@@ -0,0 +1,8 @@
+export * from "./CreditConfiguratorV300Contract";
+export * from "./CreditConfiguratorV310Contract";
+export * from "./CreditFacadeV300Contract";
+export * from "./CreditFacadeV310Contract";
+export * from "./CreditManagerV300Contract";
+export * from "./CreditManagerV310Contract";
+export * from "./CreditSuite";
+export * from "./types";

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

@@ -0,0 +1,42 @@
+import type { Address } from "abitype";
+
+import type { CreditManagerState, IBaseContract } from "../../base";
+import type {
+  CreditConfiguratorStateHuman,
+  CreditManagerStateHuman,
+} from "../../types";
+import type { AddressMap } from "../../utils";
+import type { CreditFacadeV300Contract, CreditFacadeV310Contract } from "..";
+import type { IAdapterContract } from "../adapters";
+import type { RampEvent } from "./CreditConfiguratorV300Contract";
+
+export interface ICreditConfiguratorContract extends IBaseContract {
+  adapters: Address[];
+  isPaused: boolean;
+
+  checkRamps: () => Promise<RampEvent[]>;
+  stateHuman: (raw?: boolean) => CreditConfiguratorStateHuman;
+}
+
+export interface ICreditManagerContract
+  extends IBaseContract,
+    Omit<CreditManagerState, "baseParams" | "collateralTokens"> {
+  /**
+   * Mapping targetContract => adapter
+   */
+  adapters: AddressMap<IAdapterContract>;
+  /**
+   * Mapping collateral token address => liquidation threshold
+   */
+  liquidationThresholds: AddressMap<number>;
+  /**
+   * List of collateral tokens
+   */
+  collateralTokens: Address[];
+
+  stateHuman: (raw?: boolean) => CreditManagerStateHuman;
+}
+
+export type CreditFacadeContract =
+  | CreditFacadeV300Contract
+  | CreditFacadeV310Contract;

package/src/sdk/market/index.ts

@@ -0,0 +1,7 @@
+export * from "./adapters";
+export * from "./credit";
+export * from "./MarketRegister";
+export * from "./MarketSuite";
+export * from "./oracle";
+export * from "./pool";
+export * from "./pricefeeds";

package/src/sdk/market/oracle/PriceOracleBaseContract.ts

@@ -0,0 +1,376 @@
+import type { Abi, Address } from "viem";
+import { decodeFunctionData } from "viem";
+
+import { iPriceFeedCompressorAbi } from "../../../abi/compressors";
+import { iUpdatablePriceFeedAbi } from "../../../abi/iUpdatablePriceFeed";
+import type {
+  PriceFeedMapEntry,
+  PriceFeedTreeNode,
+  PriceOracleData,
+} from "../../base";
+import { BaseContract } from "../../base";
+import type { BaseContractOptions } from "../../base/BaseContract";
+import { AP_PRICE_FEED_COMPRESSOR } from "../../constants";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PriceOracleV3StateHuman } from "../../types";
+import { AddressMap } from "../../utils";
+import type {
+  IPriceFeedContract,
+  PriceFeedUsageType,
+  UpdatePriceFeedsResult,
+} from "../pricefeeds";
+import { PriceFeedRef } from "../pricefeeds";
+import type {
+  IPriceOracleContract,
+  OnDemandPriceUpdate,
+  PriceFeedsForTokensOptions,
+} from "./types";
+
+export class PriceOracleBaseContract<abi extends Abi | readonly unknown[]>
+  extends BaseContract<abi>
+  implements IPriceOracleContract
+{
+  /**
+   * Underlying token of market to which this price oracle belongs
+   */
+  public readonly underlying: Address;
+  /**
+   * Mapping Token => [PriceFeed Address, stalenessPeriod]
+   */
+  public readonly mainPriceFeeds = new AddressMap<PriceFeedRef>(
+    undefined,
+    "mainPriceFeeds",
+  );
+  /**
+   * Mapping Token => [PriceFeed Address, stalenessPeriod]
+   */
+  public readonly reservePriceFeeds = new AddressMap<PriceFeedRef>(
+    undefined,
+    "reservePriceFeeds",
+  );
+  /**
+   * Mapping Token => Price in underlying
+   */
+  public readonly mainPrices = new AddressMap<bigint>(undefined, "mainPrices");
+  /**
+   * Mapping Token => Price in underlying
+   */
+  public readonly reservePrices = new AddressMap<bigint>(
+    undefined,
+    "reservePrices",
+  );
+
+  #priceFeedTree: readonly PriceFeedTreeNode[] = [];
+
+  constructor(
+    sdk: GearboxSDK,
+    args: BaseContractOptions<abi>,
+    data: PriceOracleData,
+    underlying: Address,
+  ) {
+    super(sdk, args);
+    this.underlying = underlying;
+    const { priceFeedMapping, priceFeedStructure } = data;
+    this.#loadState(priceFeedMapping, priceFeedStructure);
+  }
+
+  /**
+   * Returns main and reserve price feeds for given tokens
+   * @param tokens
+   * @param opts Option to include main/reserve feeds only, defaults to both
+   * @returns
+   */
+  public priceFeedsForTokens(
+    tokens: Address[],
+    opts?: PriceFeedsForTokensOptions,
+  ): IPriceFeedContract[] {
+    const main = opts?.main ?? true;
+    const reserve = opts?.reserve ?? true;
+    return tokens
+      .flatMap(t => [
+        main ? this.mainPriceFeeds.get(t)?.priceFeed : undefined,
+        reserve ? this.reservePriceFeeds.get(t)?.priceFeed : undefined,
+      ])
+      .filter((f): f is IPriceFeedContract => !!f);
+  }
+
+  /**
+   * Generates updates for all updateable price feeds in this oracle (including dependencies)
+   * @returns
+   */
+  public async updatePriceFeeds(): Promise<UpdatePriceFeedsResult> {
+    const updatables: IPriceFeedContract[] = [];
+    for (const node of this.#priceFeedTree) {
+      if (node.updatable) {
+        updatables.push(this.sdk.priceFeeds.mustGet(node.baseParams.addr));
+      }
+    }
+    return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(updatables);
+  }
+
+  /**
+   * Converts previously obtained price updates into CreditFacade multicall entries
+   * @param creditFacade
+   * @param updates
+   * @returns
+   */
+  public onDemandPriceUpdates(
+    updates?: UpdatePriceFeedsResult,
+  ): OnDemandPriceUpdate[] {
+    // TODO: really here I'm doing lots of reverse processing:
+    // decoding RawTx into Redstone calldata
+    // and then finding token + reserve value for a price feed
+    // it would be much nicer to have intermediate format and get RawTx/OnDemandPriceUpdate/ViemMulticall from it (as it's done in liquidator)
+    const result: OnDemandPriceUpdate[] = [];
+    if (!updates) {
+      this.logger?.debug("empty updates list");
+      return result;
+    }
+    const { txs } = updates;
+
+    for (const tx of txs) {
+      const { to: priceFeed, callData, description } = tx;
+      const [token, reserve] = this.findTokenForPriceFeed(priceFeed);
+      // this situation happend when we have combined updates from multiple markrts,
+      // but this particular feed is not added to this particular oracle
+      if (!token) {
+        this.logger?.debug(
+          `skipping onDemandPriceUpdate ${description}): token not found for price feed ${priceFeed} in oracle ${this.address}`,
+        );
+        continue;
+      }
+      const { args } = decodeFunctionData({
+        abi: iUpdatablePriceFeedAbi,
+        data: callData,
+      });
+      const data = args[0]!;
+      result.push({
+        priceFeed,
+        token,
+        reserve,
+        data,
+      });
+    }
+    this.logger?.debug(
+      `got ${result.length} onDemandPriceUpdates from ${txs.length} txs`,
+    );
+    return result;
+  }
+
+  /**
+   * Returns true if oracle's price feed tree contains given price feed
+   * @param priceFeed
+   * @returns
+   */
+  public usesPriceFeed(priceFeed: Address): boolean {
+    return this.#priceFeedTree.some(
+      node => node.baseParams.addr.toLowerCase() === priceFeed.toLowerCase(),
+    );
+  }
+
+  /**
+   * Tries to convert amount of token into underlying of current market
+   * @param token
+   * @param amount
+   * @param reserve
+   * @returns
+   */
+  public convertToUnderlying(
+    token: Address,
+    amount: bigint,
+    reserve = false,
+  ): bigint {
+    return this.convert(token, this.underlying, amount, reserve);
+  }
+
+  /**
+   * Tries to convert amount of from one token to another, using latest known prices
+   * @param from
+   * @param to
+   * @param amount
+   * @param reserve
+   */
+  public convert(
+    from: Address,
+    to: Address,
+    amount: bigint,
+    reserve = false,
+  ): bigint {
+    if (from === to) {
+      return amount;
+    }
+    const fromPrice = reserve
+      ? this.reservePrices.mustGet(from)
+      : this.mainPrices.mustGet(from);
+    const fromScale = 10n ** BigInt(this.sdk.tokensMeta.decimals(from));
+    const toPrice = reserve
+      ? this.reservePrices.mustGet(to)
+      : this.mainPrices.mustGet(to);
+    const toScale = 10n ** BigInt(this.sdk.tokensMeta.decimals(to));
+
+    return (amount * fromPrice * toScale) / (toPrice * fromScale);
+  }
+
+  /**
+   * Tries to convert amount of token to USD, using latest known prices
+   * @param from
+   * @param to
+   * @param amount
+   * @param reserve
+   */
+  public convertToUSD(from: Address, amount: bigint, reserve = false): bigint {
+    const price = reserve
+      ? this.reservePrices.mustGet(from)
+      : this.mainPrices.mustGet(from);
+    const scale = 10n ** BigInt(this.sdk.tokensMeta.decimals(from));
+    return (amount * price) / scale;
+  }
+
+  /**
+   * Loads new prices for this oracle from PriceFeedCompressor
+   * Does not update price feeds, only updates prices
+   */
+  public async updatePrices(): Promise<void> {
+    await this.sdk.marketRegister.updatePrices([this.address]);
+  }
+
+  public syncStateMulticall() {
+    const args: any[] = [this.address];
+    if (this.version === 300) {
+      args.push(
+        Array.from(
+          new Set([
+            this.underlying,
+            ...this.mainPriceFeeds.keys(),
+            ...this.reservePriceFeeds.keys(),
+          ]),
+        ),
+      );
+    }
+    return {
+      call: {
+        abi: iPriceFeedCompressorAbi,
+        address: this.sdk.addressProvider.getLatestVersion(
+          AP_PRICE_FEED_COMPRESSOR,
+        ),
+        functionName: "getPriceFeeds",
+        args,
+      },
+      onResult: ([entries, tree]: [
+        PriceFeedMapEntry[],
+        PriceFeedTreeNode[],
+      ]) => {
+        this.#loadState(entries, tree);
+      },
+    };
+  }
+
+  #loadState(
+    entries: readonly PriceFeedMapEntry[],
+    tree: readonly PriceFeedTreeNode[],
+  ): void {
+    this.#priceFeedTree = tree;
+    this.mainPriceFeeds.clear();
+    this.reservePriceFeeds.clear();
+    this.mainPrices.clear();
+    this.reservePrices.clear();
+
+    for (const node of tree) {
+      this.sdk.priceFeeds.getOrCreate(node);
+    }
+
+    entries.forEach(entry => {
+      const { token, priceFeed, reserve, stalenessPeriod } = entry;
+      const ref = new PriceFeedRef(this.sdk, priceFeed, stalenessPeriod);
+      const node = this.#priceFeedTree.find(
+        n => n.baseParams.addr === priceFeed,
+      );
+      const price = node?.answer?.price;
+      if (reserve) {
+        this.reservePriceFeeds.upsert(token, ref);
+        if (price) {
+          this.reservePrices.upsert(token, price);
+        } else {
+          this.logger?.warn(
+            `answer not found for reserve price feed ${this.labelAddress(priceFeed)}, success: ${node?.answer?.success}`,
+          );
+        }
+      } else {
+        this.mainPriceFeeds.upsert(token, ref);
+        if (price) {
+          this.mainPrices.upsert(token, price);
+        } else {
+          this.logger?.warn(
+            `answer not found for main price feed ${this.labelAddress(priceFeed)}, success: ${node?.answer?.success}`,
+          );
+        }
+      }
+      this.#labelPriceFeed(priceFeed, reserve ? "Reserve" : "Main", token);
+    });
+
+    this.logger?.debug(
+      `Got ${this.mainPriceFeeds.size} main and ${this.reservePriceFeeds.size} reserve price feeds`,
+    );
+  }
+
+  #labelPriceFeed(
+    address: Address,
+    usage: PriceFeedUsageType,
+    token: Address,
+  ): void {
+    this.sdk.provider.addressLabels.set(address, oldLabel => {
+      const symbol = this.sdk.tokensMeta.symbol(token);
+      let pricefeedTag = `${symbol}.${usage}`;
+
+      if (oldLabel) {
+        const oldLabelParts = new Set(oldLabel.split(", "));
+        oldLabelParts.add(pricefeedTag);
+        pricefeedTag = Array.from(oldLabelParts).join(", ");
+      }
+      return pricefeedTag;
+    });
+  }
+
+  /**
+   * Helper method to find "attachment point" of price feed (makes sense for updatable price feeds only) -
+   * returns token (in v3.0 can be ticker) and main/reserve flag
+   *
+   * @param priceFeed
+   * @returns
+   */
+  protected findTokenForPriceFeed(
+    priceFeed: Address,
+  ): [token: Address | undefined, reserve: boolean] {
+    for (const [token, pf] of this.mainPriceFeeds.entries()) {
+      if (pf.address === priceFeed) {
+        return [token, false];
+      }
+    }
+    for (const [token, pf] of this.reservePriceFeeds.entries()) {
+      if (pf.address === priceFeed) {
+        return [token, true];
+      }
+    }
+    return [undefined, false];
+  }
+
+  public override stateHuman(raw = true): PriceOracleV3StateHuman {
+    return {
+      ...super.stateHuman(raw),
+      mainPriceFeeds: Object.fromEntries(
+        this.mainPriceFeeds
+          .entries()
+          .map(([token, v]) => [this.labelAddress(token), v.stateHuman(raw)]),
+      ),
+      reservePriceFeeds: Object.fromEntries(
+        this.reservePriceFeeds
+          .entries()
+          .map(([token, v]) => [this.labelAddress(token), v.stateHuman(raw)]),
+      ),
+    };
+  }
+
+  protected get priceFeedTree(): readonly PriceFeedTreeNode[] {
+    return this.#priceFeedTree;
+  }
+}