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

package/src/sdk/market/MarketRegister.ts

@@ -0,0 +1,330 @@
+import type { Address } from "viem";
+
+import {
+  iMarketCompressorAbi,
+  iPeripheryCompressorAbi,
+} from "../../abi/compressors";
+import type { MarketData, MarketFilter, ZapperData } from "../base";
+import { SDKConstruct } from "../base";
+import {
+  ADDRESS_0X0,
+  AP_MARKET_COMPRESSOR,
+  AP_PERIPHERY_COMPRESSOR,
+} from "../constants";
+import type { GearboxSDK } from "../GearboxSDK";
+import type {
+  ILogger,
+  MarketStateHuman,
+  RawTx,
+  TVL,
+  ZapperStateHuman,
+} from "../types";
+import { AddressMap, childLogger } from "../utils";
+import { simulateMulticall } from "../utils/viem";
+import type { CreditSuite } from "./credit";
+import type { MarketConfiguratorContract } from "./MarketConfiguratorContract";
+import { MarketSuite } from "./MarketSuite";
+import type { PoolSuite } from "./pool";
+import { rawTxToMulticallPriceUpdate } from "./pricefeeds";
+
+export interface ZapperDataFull extends ZapperData {
+  pool: Address;
+}
+
+export class MarketRegister extends SDKConstruct {
+  #logger?: ILogger;
+  /**
+   * Mapping pool.address -> MarketSuite
+   */
+  #markets = new AddressMap<MarketSuite>(undefined, "markets");
+  #zappers = new AddressMap<Array<ZapperDataFull>>(undefined, "zappers");
+
+  #marketFilter?: MarketFilter;
+
+  constructor(sdk: GearboxSDK, markets?: MarketData[]) {
+    super(sdk);
+    this.#logger = childLogger("MarketRegister", sdk.logger);
+    for (const data of markets ?? []) {
+      this.#markets.upsert(
+        data.pool.baseParams.addr,
+        new MarketSuite(this.sdk, data),
+      );
+    }
+  }
+
+  public async loadMarkets(
+    marketConfigurators: Address[],
+    ignoreUpdateablePrices?: boolean,
+  ): Promise<void> {
+    if (!marketConfigurators.length) {
+      this.#logger?.warn(
+        "no market configurators provided, skipping loadMarkets",
+      );
+      return;
+    }
+    await this.#loadMarkets(marketConfigurators, [], ignoreUpdateablePrices);
+  }
+
+  public async loadZappers(): Promise<void> {
+    const pcAddr = this.sdk.addressProvider.getAddress(
+      AP_PERIPHERY_COMPRESSOR,
+      3_10,
+    );
+    this.#logger?.debug(`loading zappers with periphery compressor ${pcAddr}`);
+    const resp = await this.provider.publicClient.multicall({
+      contracts: this.markets.map(m => ({
+        abi: iPeripheryCompressorAbi,
+        address: pcAddr,
+        functionName: "getZappers",
+        args: [m.configurator.address, m.pool.pool.address],
+      })),
+      allowFailure: true,
+    });
+
+    for (let i = 0; i < resp.length; i++) {
+      const { status, result, error } = resp[i];
+      const marketConfigurator = this.markets[i].configurator.address;
+      const pool = this.markets[i].pool.pool.address;
+
+      if (status === "success") {
+        const list = result as any as ZapperData[];
+
+        this.#zappers.upsert(
+          pool,
+          list.map(z => ({ ...z, pool })),
+        );
+      } else {
+        this.#logger?.error(
+          `failed to load zapper for market configurator ${this.labelAddress(marketConfigurator)} and pool ${this.labelAddress(pool)}: ${error}`,
+        );
+      }
+    }
+
+    const zappersTokens = this.#zappers
+      .values()
+      .flatMap(l => l.flatMap(z => [z.tokenIn, z.tokenOut]));
+    for (const t of zappersTokens) {
+      this.sdk.tokensMeta.upsert(t.addr, t);
+      this.sdk.provider.addressLabels.set(t.addr as Address, t.symbol);
+    }
+  }
+
+  get marketFilter() {
+    return this.#marketFilter;
+  }
+
+  public async syncState(): Promise<void> {
+    const pools = this.markets
+      .filter(m => m.dirty)
+      .map(m => m.pool.pool.address);
+    if (pools.length) {
+      this.#logger?.debug(`need to reload ${pools.length} markets`);
+      await this.#loadMarkets([], pools);
+    }
+  }
+
+  async #loadMarkets(
+    configurators: Address[],
+    pools: Address[],
+    ignoreUpdateablePrices?: boolean,
+  ): Promise<void> {
+    this.#marketFilter = {
+      configurators,
+      pools,
+      underlying: ADDRESS_0X0,
+    };
+    const marketCompressorAddress = this.sdk.addressProvider.getAddress(
+      AP_MARKET_COMPRESSOR,
+      3_10,
+    );
+    let txs: RawTx[] = [];
+    if (!ignoreUpdateablePrices) {
+      // to have correct prices we must first get all updatable price feeds
+      await this.sdk.priceFeeds.preloadUpdatablePriceFeeds(
+        configurators,
+        pools,
+      );
+      // the generate updates
+      const updates = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
+      txs = updates.txs;
+    }
+    this.#logger?.debug(
+      { configurators, pools },
+      `calling getMarkets with ${txs.length} price updates`,
+    );
+    // ...and push them using multicall before getting answers
+    let markets: readonly MarketData[] = [];
+    if (txs.length) {
+      const resp = await simulateMulticall(this.provider.publicClient, {
+        contracts: [
+          ...txs.map(rawTxToMulticallPriceUpdate),
+          {
+            abi: iMarketCompressorAbi,
+            address: marketCompressorAddress,
+            functionName: "getMarkets",
+            args: [this.#marketFilter],
+          },
+        ],
+        allowFailure: false,
+        // gas: 550_000_000n,
+        batchSize: 0, // we cannot have price updates and compressor request in different batches
+      });
+      markets = resp.pop() as MarketData[];
+    } else {
+      markets = await this.provider.publicClient.readContract({
+        abi: iMarketCompressorAbi,
+        address: marketCompressorAddress,
+        functionName: "getMarkets",
+        args: [this.#marketFilter],
+        // gas: 550_000_000n,
+      });
+    }
+
+    for (const data of markets) {
+      this.#markets.upsert(
+        data.pool.baseParams.addr,
+        new MarketSuite(this.sdk, data),
+      );
+    }
+
+    this.#logger?.info(`loaded ${markets.length} markets`);
+  }
+
+  /**
+   * Loads new prices and price feeds for given oracles from PriceFeedCompressor, defaults to all oracles
+   * Supports v300 and v310 oracles
+   */
+  public async updatePrices(oracles?: Address[]): Promise<void> {
+    const multicalls = this.markets
+      .map(m => m.priceOracle)
+      .filter(o => !oracles || oracles.includes(o.address))
+      .map(o => o.syncStateMulticall());
+    if (!multicalls.length) {
+      return;
+    }
+    const { txs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
+    const resp = await simulateMulticall(this.provider.publicClient, {
+      contracts: [
+        ...txs.map(rawTxToMulticallPriceUpdate),
+        ...multicalls.map(mc => mc.call),
+      ],
+      allowFailure: false,
+      // gas: 550_000_000n,
+      batchSize: 0, // we cannot have price updates and compressor request in different batches
+    });
+    const oraclesStates = resp.slice(txs.length);
+    for (let i = 0; i < multicalls.length; i++) {
+      const handler = multicalls[i].onResult;
+      const result = oraclesStates[i] as any;
+      handler(result);
+    }
+  }
+
+  public get state(): MarketData[] {
+    return this.markets.map(market => market.state);
+  }
+
+  public stateHuman(raw = true): {
+    markets: MarketStateHuman[];
+    zappers: ZapperStateHuman[];
+  } {
+    return {
+      markets: this.markets.map(market => market.stateHuman(raw)),
+      zappers: this.zappers.values().flatMap(l =>
+        l.flatMap(z => ({
+          address: z.baseParams.addr,
+          contractType: z.baseParams.contractType,
+          version: Number(z.baseParams.version),
+          tokenIn: this.labelAddress(z.tokenIn.addr),
+          tokenOut: this.labelAddress(z.tokenOut.addr),
+        })),
+      ),
+    };
+  }
+
+  public get pools(): PoolSuite[] {
+    return this.markets.map(market => market.pool);
+  }
+
+  public get creditManagers(): CreditSuite[] {
+    return this.markets.flatMap(market => market.creditManagers);
+  }
+
+  public get marketConfigurators(): MarketConfiguratorContract[] {
+    const result = new Set<MarketConfiguratorContract>();
+    for (const m of this.markets) {
+      result.add(m.configurator);
+    }
+    return Array.from(result);
+  }
+
+  public findCreditManager(creditManager: Address): CreditSuite {
+    const addr = creditManager.toLowerCase();
+    for (const market of this.markets) {
+      for (const cm of market.creditManagers) {
+        if (cm.creditManager.address.toLowerCase() === addr) {
+          return cm;
+        }
+      }
+    }
+    throw new Error(`cannot find credit manager ${creditManager}`);
+  }
+
+  public findByCreditManager(creditManager: Address): MarketSuite {
+    const addr = creditManager.toLowerCase();
+    const market = this.markets.find(m =>
+      m.creditManagers.some(
+        cm => cm.creditManager.address.toLowerCase() === addr,
+      ),
+    );
+    if (!market) {
+      throw new Error(`cannot find market for credit manager ${creditManager}`);
+    }
+    return market;
+  }
+
+  public findByPriceOracle(address: Address): MarketSuite {
+    const addr = address.toLowerCase();
+    for (const market of this.markets) {
+      if (market.priceOracle.address.toLowerCase() === addr) {
+        return market;
+      }
+    }
+    throw new Error(`cannot find market for price oracle ${address}`);
+  }
+
+  public findByPool(address: Address): MarketSuite {
+    const addr = address.toLowerCase();
+    for (const market of this.markets) {
+      if (market.pool.pool.address.toLowerCase() === addr) {
+        return market;
+      }
+    }
+    throw new Error(`cannot find market for pool ${address}`);
+  }
+
+  public get marketsMap() {
+    return this.#markets;
+  }
+
+  public get zappers() {
+    return this.#zappers;
+  }
+
+  public get markets(): MarketSuite[] {
+    return this.#markets.values();
+  }
+
+  public async tvl(): Promise<TVL> {
+    const creditManagers = this.creditManagers;
+    const tvls = await Promise.all(creditManagers.map(cm => cm.tvl()));
+    return tvls.reduce(
+      (acc, curr) => {
+        acc.tvl += curr.tvl;
+        acc.tvlUSD += curr.tvlUSD;
+        return acc;
+      },
+      { tvl: 0n, tvlUSD: 0n },
+    );
+  }
+}

package/src/sdk/market/MarketSuite.ts

@@ -0,0 +1,83 @@
+import type { Address } from "viem";
+
+import type { MarketData } from "../base";
+import { SDKConstruct } from "../base";
+import type { GearboxSDK } from "../GearboxSDK";
+import type { MarketStateHuman } from "../types";
+import { CreditSuite } from "./credit";
+import { MarketConfiguratorContract } from "./MarketConfiguratorContract";
+import type { PriceOracleContract } from "./oracle";
+import { createPriceOracle } from "./oracle";
+import { PoolSuite } from "./pool";
+
+export class MarketSuite extends SDKConstruct {
+  public readonly acl: Address;
+  public readonly configurator: MarketConfiguratorContract;
+  public readonly pool: PoolSuite;
+  public readonly priceOracle: PriceOracleContract;
+  public readonly creditManagers: CreditSuite[] = [];
+  /**
+   * Original data received from compressor
+   */
+  public readonly state: MarketData;
+
+  constructor(sdk: GearboxSDK, marketData: MarketData) {
+    super(sdk);
+    this.state = marketData;
+
+    let configurator = sdk.contracts.get(
+      marketData.configurator,
+    ) as unknown as MarketConfiguratorContract;
+    if (!configurator) {
+      configurator = new MarketConfiguratorContract(
+        sdk,
+        marketData.configurator,
+      );
+    }
+    this.configurator = configurator;
+
+    this.acl = marketData.acl;
+
+    for (const t of marketData.tokens) {
+      sdk.tokensMeta.upsert(t.addr, t);
+      sdk.provider.addressLabels.set(t.addr as Address, t.symbol);
+    }
+
+    this.pool = new PoolSuite(sdk, marketData);
+
+    for (let i = 0; i < marketData.creditManagers.length; i++) {
+      this.creditManagers.push(new CreditSuite(sdk, marketData, i));
+    }
+
+    this.priceOracle = createPriceOracle(
+      sdk,
+      marketData.priceOracleData,
+      marketData.pool.underlying,
+    );
+  }
+
+  override get dirty(): boolean {
+    return (
+      this.configurator.dirty ||
+      this.pool.dirty ||
+      this.priceOracle.dirty ||
+      this.creditManagers.some(cm => cm.dirty)
+    );
+  }
+
+  public stateHuman(raw = true): MarketStateHuman {
+    return {
+      configurator: this.labelAddress(this.configurator.address),
+      pool: this.pool.stateHuman(raw),
+      creditManagers: this.creditManagers.map(cm => cm.stateHuman(raw)),
+      priceOracle: this.priceOracle.stateHuman(raw),
+      pausableAdmins: this.state.pausableAdmins.map(a => this.labelAddress(a)),
+      unpausableAdmins: this.state.unpausableAdmins.map(a =>
+        this.labelAddress(a),
+      ),
+      emergencyLiquidators: this.state.emergencyLiquidators.map(a =>
+        this.labelAddress(a),
+      ),
+    };
+  }
+}

package/src/sdk/market/adapters/PlaceholderAdapterContracts.ts

@@ -0,0 +1,18 @@
+import type { Address } from "viem";
+
+import type { AdapterData } from "../../base";
+import { PlaceholderContract } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { IAdapterContract } from "./types";
+
+export class PlaceholderAdapterContract
+  extends PlaceholderContract
+  implements IAdapterContract
+{
+  public readonly targetContract: Address;
+
+  constructor(sdk: GearboxSDK, args: AdapterData) {
+    super(sdk, args.baseParams);
+    this.targetContract = args.targetContract;
+  }
+}

package/src/sdk/market/adapters/factory.ts

@@ -0,0 +1,34 @@
+import type { Hex } from "viem";
+
+import type { AdapterData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { bytes32ToString } from "../../utils";
+import { PlaceholderAdapterContract } from "./PlaceholderAdapterContracts";
+import type { IAdapterContract } from "./types";
+
+export function createAdapter(
+  sdk: GearboxSDK,
+  args: AdapterData,
+): IAdapterContract {
+  const adapterType = bytes32ToString(args.baseParams.contractType as Hex);
+  for (const plugin of sdk.plugins) {
+    try {
+      const adapter = plugin.createContract(sdk, args);
+      if (adapter) {
+        sdk.logger?.info(
+          ` ${adapterType} v${args.baseParams.version} created using plugin ${plugin.name}`,
+        );
+        return adapter as IAdapterContract;
+      }
+    } catch (e) {
+      sdk.logger?.warn(
+        `plugin ${plugin.name} error while trying to create ${adapterType} v${args.baseParams.version}: ${e}`,
+      );
+    }
+  }
+
+  sdk.logger?.warn(
+    `no class found for ${adapterType} v${args.baseParams.version}, falling back to placeholder`,
+  );
+  return new PlaceholderAdapterContract(sdk, args);
+}

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

@@ -0,0 +1,3 @@
+export * from "./factory";
+export * from "./PlaceholderAdapterContracts";
+export * from "./types";

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

@@ -0,0 +1,7 @@
+import type { Address } from "viem";
+
+import type { IBaseContract } from "../../base";
+
+export interface IAdapterContract extends IBaseContract {
+  targetContract: Address;
+}

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

@@ -0,0 +1,164 @@
+import type {
+  Address,
+  ContractEventName,
+  DecodeFunctionDataReturnType,
+  GetEventArgs,
+  Log,
+} from "viem";
+
+import { iPausableAbi } from "../../../abi/iPausable";
+import { iCreditConfiguratorV300Abi } from "../../../abi/v300";
+import type { CreditManagerData } from "../../base";
+import { BaseContract } from "../../base";
+import { RAMP_DURATION_BY_NETWORK } from "../../constants";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { formatDuration, percentFmt } from "../../utils";
+import type { ICreditConfiguratorContract } from "./types";
+
+const abi = [...iCreditConfiguratorV300Abi, ...iPausableAbi] as const;
+type abi = typeof abi;
+
+export type RampEvent = GetEventArgs<
+  abi,
+  "ScheduleTokenLiquidationThresholdRamp",
+  {
+    EnableUnion: false;
+    IndexedOnly: false;
+    Required: true;
+  }
+>;
+
+export class CreditConfiguratorV300Contract
+  extends BaseContract<abi>
+  implements ICreditConfiguratorContract
+{
+  public readonly adapters: Address[] = [];
+  public isPaused = false;
+
+  constructor(
+    sdk: GearboxSDK,
+    { creditConfigurator, creditManager }: CreditManagerData,
+  ) {
+    super(sdk, {
+      ...creditConfigurator.baseParams,
+      name: `CreditConfigurator(${creditManager.name})`,
+      abi,
+    });
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "Paused":
+        this.isPaused = true;
+        break;
+      case "Unpaused":
+        this.isPaused = false;
+        break;
+      case "AddCollateralToken":
+      case "AddEmergencyLiquidator":
+      case "AllowAdapter":
+      case "AllowToken":
+      case "CreditConfiguratorUpgraded":
+      case "ForbidAdapter":
+      case "ForbidToken":
+      case "QuoteToken":
+      case "RemoveEmergencyLiquidator":
+      case "ResetCumulativeLoss":
+      case "ScheduleTokenLiquidationThresholdRamp":
+      case "SetBorrowingLimits":
+      case "SetBotList":
+      case "SetCreditFacade":
+      case "SetExpirationDate":
+      case "SetMaxCumulativeLoss":
+      case "SetMaxDebtPerBlockMultiplier":
+      case "SetMaxEnabledTokens":
+      case "SetPriceOracle":
+      case "SetTokenLiquidationThreshold":
+      case "UpdateFees":
+        this.dirty = true;
+        break;
+    }
+  }
+
+  public async checkRamps(): Promise<RampEvent[]> {
+    let fromBlock =
+      this.sdk.currentBlock -
+      RAMP_DURATION_BY_NETWORK[this.sdk.provider.networkType];
+    fromBlock = fromBlock < 0n ? 0n : fromBlock;
+
+    const logs = await this.provider.publicClient.getContractEvents({
+      address: this.address,
+      abi: this.abi,
+      fromBlock,
+      eventName: "ScheduleTokenLiquidationThresholdRamp",
+      strict: true,
+    });
+
+    return logs.map(({ args }) => args);
+  }
+
+  public parseFunctionParams(
+    params: DecodeFunctionDataReturnType<abi>,
+  ): Array<string> | undefined {
+    switch (params.functionName) {
+      case "addCollateralToken":
+      case "setLiquidationThreshold": {
+        const [token, lt] = params.args;
+        return [this.labelAddress(token), percentFmt(lt)];
+      }
+      case "setExpirationDate": {
+        const [expirationDate] = params.args;
+        // TODO: add date format
+        return [`${expirationDate}`];
+      }
+      case "setFees": {
+        const [
+          feeInterest,
+          feeLiquidation,
+          liquidationPremium,
+          feeLiquidationExpired,
+          liquidationPremiumExpired,
+        ] = params.args;
+        return [
+          percentFmt(feeInterest),
+          percentFmt(feeLiquidation),
+          percentFmt(liquidationPremium),
+          percentFmt(feeLiquidationExpired),
+          percentFmt(liquidationPremiumExpired),
+        ];
+      }
+      // case "setMinDebtLimit":
+      // case "setMaxDebtLimit": {
+      //   const [debt] = params.args;
+      //   return [this.factory.convertUnderlying(debt)];
+      // }
+      case "setCreditFacade": {
+        const [newCreditFacade, migrateParams] = params.args;
+        return [this.labelAddress(newCreditFacade), `${migrateParams}`];
+      }
+      case "rampLiquidationThreshold": {
+        const [token, liquidationThresholdFinal, rampStart, rampDuration] =
+          params.args;
+        return [
+          this.labelAddress(token),
+          percentFmt(liquidationThresholdFinal),
+          `${rampStart}`,
+          formatDuration(rampDuration),
+        ];
+      }
+
+      default:
+        return undefined;
+    }
+  }
+}