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

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

@@ -0,0 +1,71 @@
+import type { Address, ContractEventName, Log } from "viem";
+
+import { iPausableAbi } from "../../../abi/iPausable";
+import { iPriceOracleV300Abi } from "../../../abi/v300";
+import type { PriceOracleData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { tickerInfoTokensByNetwork } from "../../sdk-gov-legacy";
+import { PriceOracleBaseContract } from "./PriceOracleBaseContract";
+
+const abi = [...iPriceOracleV300Abi, ...iPausableAbi];
+type abi = typeof abi;
+
+export class PriceOracleV300Contract extends PriceOracleBaseContract<abi> {
+  constructor(sdk: GearboxSDK, data: PriceOracleData, underlying: Address) {
+    super(
+      sdk,
+      {
+        ...data.baseParams,
+        name: "PriceOracleV3",
+        abi,
+      },
+      data,
+      underlying,
+    );
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "Paused":
+      case "Unpaused":
+        break;
+      case "SetPriceFeed":
+      case "SetReservePriceFeed":
+      case "SetReservePriceFeedStatus":
+        this.dirty = true;
+        break;
+    }
+  }
+
+  protected override findTokenForPriceFeed(
+    priceFeed: Address,
+  ): [token: Address | undefined, reserve: boolean] {
+    const [token, reserve] = super.findTokenForPriceFeed(priceFeed);
+    if (token) {
+      return [token, reserve];
+    }
+    const tickers = Object.values(
+      tickerInfoTokensByNetwork[this.sdk.provider.networkType],
+    ).flat();
+    const ticker = tickers.find(
+      t => t.priceFeed.toLowerCase() === priceFeed.toLowerCase(),
+    );
+    if (ticker) {
+      this.logger?.debug(
+        `will use ticker ${ticker.symbol} (${ticker.address}) for price feed ${priceFeed}`,
+      );
+      return [ticker.address, false];
+    }
+    return [undefined, false];
+  }
+}

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

@@ -0,0 +1,43 @@
+import type { Address, ContractEventName, Log } from "viem";
+
+import { iPriceOracleV310Abi } from "../../../abi/v310";
+import type { PriceOracleData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { PriceOracleBaseContract } from "./PriceOracleBaseContract";
+
+const abi = iPriceOracleV310Abi;
+type abi = typeof abi;
+
+export class PriceOracleV310Contract extends PriceOracleBaseContract<abi> {
+  constructor(sdk: GearboxSDK, data: PriceOracleData, underlying: Address) {
+    super(
+      sdk,
+      {
+        ...data.baseParams,
+        name: "PriceOracleV3",
+        abi,
+      },
+      data,
+      underlying,
+    );
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "SetPriceFeed":
+      case "SetReservePriceFeed":
+        this.dirty = true;
+        break;
+    }
+  }
+}

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

@@ -0,0 +1,22 @@
+import type { Address } from "abitype";
+
+import type { PriceOracleData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { PriceOracleV300Contract } from "./PriceOracleV300Contract";
+import { PriceOracleV310Contract } from "./PriceOracleV310Contract";
+import type { PriceOracleContract } from "./types";
+
+export function createPriceOracle(
+  sdk: GearboxSDK,
+  data: PriceOracleData,
+  underlying: Address,
+): PriceOracleContract {
+  const v = data.baseParams.version;
+  if (v >= 300n && v < 310n) {
+    return new PriceOracleV300Contract(sdk, data, underlying);
+  }
+  if (v === 310n) {
+    return new PriceOracleV310Contract(sdk, data, underlying);
+  }
+  throw new Error(`Unsupported oracle version ${v}`);
+}

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

@@ -0,0 +1,4 @@
+export * from "./createPriceOracle";
+export * from "./PriceOracleV300Contract";
+export * from "./PriceOracleV310Contract";
+export * from "./types";

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

@@ -0,0 +1,48 @@
+import type { Address, Hex } from "viem";
+
+import type { IBaseContract } from "../../base";
+import type { PriceOracleV310Contract } from "..";
+import type { IPriceFeedContract, UpdatePriceFeedsResult } from "../pricefeeds";
+import type { PriceOracleV300Contract } from "./PriceOracleV300Contract";
+
+export type PriceOracleContract =
+  | PriceOracleV300Contract
+  | PriceOracleV310Contract;
+
+export interface PriceFeedsForTokensOptions {
+  main?: boolean;
+  reserve?: boolean;
+}
+
+/**
+ * Data to be passed to credit facade's multicall
+ * Compatible with both v300 and v310 facades
+ */
+export interface OnDemandPriceUpdate {
+  priceFeed: Address;
+  token: Address;
+  reserve: boolean;
+  data: Hex;
+}
+
+export interface IPriceOracleContract extends IBaseContract {
+  priceFeedsForTokens: (
+    tokens: Address[],
+    opts?: PriceFeedsForTokensOptions,
+  ) => IPriceFeedContract[];
+  updatePriceFeeds: () => Promise<UpdatePriceFeedsResult>;
+  onDemandPriceUpdates: (
+    updates?: UpdatePriceFeedsResult,
+  ) => OnDemandPriceUpdate[];
+  convertToUnderlying: (
+    token: Address,
+    amount: bigint,
+    reserve?: boolean,
+  ) => bigint;
+  convert: (
+    from: Address,
+    to: Address,
+    amount: bigint,
+    reserve?: boolean,
+  ) => bigint;
+}

package/src/sdk/market/pool/GaugeContract.ts

@@ -0,0 +1,120 @@
+import type { ContractEventName, Log } from "viem";
+import { decodeAbiParameters } from "viem";
+
+import { iGaugeV300Abi } from "../../../abi/v300";
+import type { PoolData, RateKeeperData } from "../../base";
+import { BaseContract } from "../../base";
+import { WAD } from "../../constants";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { GaugeStateHuman } from "../../types";
+import { AddressMap, percentFmt } from "../../utils";
+import type { IRateKeeperContract } from "./types";
+
+const abi = iGaugeV300Abi;
+type abi = typeof abi;
+
+export interface GaugeParams {
+  minRate: number;
+  maxRate: number;
+  totalVotesLpSide: bigint;
+  totalVotesCaSide: bigint;
+  rate: number;
+}
+
+export class GaugeContract
+  extends BaseContract<abi>
+  implements IRateKeeperContract
+{
+  public readonly quotaParams: AddressMap<GaugeParams>;
+  public readonly epochFrozen: boolean;
+  public readonly epochLastUpdate: number;
+  public readonly rates: AddressMap<number>;
+
+  constructor(sdk: GearboxSDK, pool: PoolData, gauge: RateKeeperData) {
+    super(sdk, {
+      ...gauge.baseParams,
+      name: `Gauge(${pool.name})`,
+      abi: iGaugeV300Abi,
+    });
+
+    const [_voter, epochLastUpdate, epochFrozen, gaugeTokens, gaugeParams] =
+      decodeAbiParameters(
+        [
+          { name: "voter", type: "address" },
+          { name: "epochLastUpdate", type: "uint16" },
+          { name: "epochFrozen", type: "bool" },
+          { name: "tokens", type: "address[]" },
+          {
+            name: "quotaParams",
+            type: "tuple[]",
+            components: [
+              { name: "minRate", type: "uint16" },
+              { name: "maxRate", type: "uint16" },
+              { name: "totalVotesLpSide", type: "uint96" },
+              { name: "totalVotesCaSide", type: "uint96" },
+            ],
+          },
+        ],
+        gauge.baseParams.serializedParams,
+      );
+    this.epochFrozen = epochFrozen;
+    this.epochLastUpdate = epochLastUpdate;
+    this.rates = new AddressMap(gauge.rates.map(r => [r.token, r.rate]));
+    this.quotaParams = new AddressMap();
+    for (let i = 0; i < gaugeParams.length; i++) {
+      const token = gaugeTokens[i];
+      const params = gaugeParams[i];
+      this.quotaParams.upsert(token, {
+        minRate: params.minRate,
+        maxRate: params.maxRate,
+        totalVotesLpSide: params.totalVotesLpSide,
+        totalVotesCaSide: params.totalVotesCaSide,
+        rate: this.rates.get(token) ?? 0,
+      });
+    }
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "AddQuotaToken":
+      case "SetFrozenEpoch":
+      case "SetQuotaTokenParams":
+      case "Unvote":
+      case "UpdateEpoch":
+      case "Vote":
+        this.dirty = true;
+        break;
+    }
+  }
+
+  public override stateHuman(raw?: boolean): GaugeStateHuman {
+    return {
+      ...super.stateHuman(raw),
+      epochLastUpdate: Number(this.epochLastUpdate),
+      epochFrozen: this.epochFrozen,
+      quotaParams: this.quotaParams.entries().reduce(
+        (acc, [address, params]) => ({
+          ...acc,
+          [this.labelAddress(address)]: {
+            minRate: percentFmt(params.minRate, raw),
+            maxRate: percentFmt(params.maxRate, raw),
+            totalVotesLpSide: params.totalVotesLpSide / WAD,
+            totalVotesCaSide: params.totalVotesCaSide / WAD,
+            rate: percentFmt(params.rate, raw),
+          },
+        }),
+        {},
+      ),
+    };
+  }
+}

package/src/sdk/market/pool/LinearInterestRateModelContract.ts

@@ -0,0 +1,75 @@
+import { decodeAbiParameters } from "viem";
+
+import { iLinearInterestRateModelV300Abi } from "../../../abi/v300";
+import type { BaseState } from "../../base";
+import { BaseContract } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { LinearInterestRateModelStateHuman } from "../../types";
+import { percentFmt } from "../../utils";
+import type { IInterestRateModelContract } from "./types";
+
+const abi = iLinearInterestRateModelV300Abi;
+type abi = typeof abi;
+
+export class LinearInterestRateModelContract
+  extends BaseContract<abi>
+  implements IInterestRateModelContract
+{
+  public readonly U1: number;
+  public readonly U2: number;
+  public readonly Rbase: number;
+  public readonly Rslope1: number;
+  public readonly Rslope2: number;
+  public readonly Rslope3: number;
+  public readonly isBorrowingMoreU2Forbidden: boolean;
+
+  constructor(sdk: GearboxSDK, params: BaseState) {
+    super(sdk, {
+      ...params.baseParams,
+      name: "LinearInterestRateModel",
+      abi,
+    });
+
+    const [
+      U1,
+      U2,
+      Rbase,
+      Rslope1,
+      Rslope2,
+      Rslope3,
+      isBorrowingMoreU2Forbidden,
+    ] = decodeAbiParameters(
+      [
+        { type: "uint16", name: "U1" },
+        { type: "uint16", name: "U2" },
+        { type: "uint16", name: "Rbase" },
+        { type: "uint16", name: "Rslope1" },
+        { type: "uint16", name: "Rslope2" },
+        { type: "uint16", name: "Rslope3" },
+        { type: "bool", name: "isBorrowingMoreU2Forbidden" },
+      ],
+      params.baseParams.serializedParams,
+    );
+
+    this.U1 = U1;
+    this.U2 = U2;
+    this.Rbase = Rbase;
+    this.Rslope1 = Rslope1;
+    this.Rslope2 = Rslope2;
+    this.Rslope3 = Rslope3;
+    this.isBorrowingMoreU2Forbidden = isBorrowingMoreU2Forbidden;
+  }
+
+  public override stateHuman(raw?: boolean): LinearInterestRateModelStateHuman {
+    return {
+      ...super.stateHuman(raw),
+      U1: percentFmt(this.U1, raw),
+      U2: percentFmt(this.U2, raw),
+      Rbase: percentFmt(this.Rbase, raw),
+      Rslope1: percentFmt(this.Rslope1, raw),
+      Rslope2: percentFmt(this.Rslope2, raw),
+      Rslope3: percentFmt(this.Rslope3, raw),
+      isBorrowingMoreU2Forbidden: this.isBorrowingMoreU2Forbidden,
+    };
+  }
+}

package/src/sdk/market/pool/PoolQuotaKeeperV300Contract.ts

@@ -0,0 +1,89 @@
+import type { ContractEventName, Log } from "viem";
+
+import { iPoolQuotaKeeperV300Abi } from "../../../abi/v300";
+import type {
+  IBaseContract,
+  PoolData,
+  PoolQuotaKeeperData,
+  QuotaState,
+} from "../../base";
+import { BaseContract } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PoolQuotaKeeperStateHuman } from "../../types";
+import { AddressMap, formatBNvalue, percentFmt } from "../../utils";
+
+const abi = iPoolQuotaKeeperV300Abi;
+type abi = typeof abi;
+
+export class PoolQuotaKeeperV300Contract
+  extends BaseContract<abi>
+  implements IBaseContract
+{
+  public readonly decimals: number;
+  public readonly quotas: AddressMap<QuotaState>;
+
+  constructor(sdk: GearboxSDK, pool: PoolData, pqk: PoolQuotaKeeperData) {
+    super(sdk, {
+      ...pqk.baseParams,
+      name: `PoolQuotaKeeper(${pool.name})`,
+      abi,
+    });
+
+    this.decimals = pool.decimals;
+
+    this.quotas = new AddressMap(
+      pqk.quotas.map(q => {
+        return [q.token, q];
+      }),
+      "quotas",
+    );
+  }
+
+  public override stateHuman(raw = true): PoolQuotaKeeperStateHuman {
+    return {
+      ...super.stateHuman(raw),
+      quotas: this.quotas.entries().reduce(
+        (acc, [address, params]) => ({
+          ...acc,
+          [this.labelAddress(address)]: {
+            rate: percentFmt(params.rate, raw),
+            quotaIncreaseFee: percentFmt(params.quotaIncreaseFee, raw),
+            totalQuoted: formatBNvalue(
+              params.totalQuoted,
+              this.decimals,
+              2,
+              raw,
+            ),
+            limit: formatBNvalue(params.limit, this.decimals, 2, raw),
+            isActive: params.isActive,
+          },
+        }),
+        {},
+      ),
+    };
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "AddCreditManager":
+      case "AddQuotaToken":
+      case "SetGauge":
+      case "SetQuotaIncreaseFee":
+      case "SetTokenLimit":
+      case "UpdateQuota":
+      case "UpdateTokenQuotaRate":
+        this.dirty = true;
+        break;
+    }
+  }
+}

package/src/sdk/market/pool/PoolQuotaKeeperV310Contract.ts

@@ -0,0 +1,89 @@
+import type { ContractEventName, Log } from "viem";
+
+import { iPoolQuotaKeeperV310Abi } from "../../../abi/v310";
+import type {
+  IBaseContract,
+  PoolData,
+  PoolQuotaKeeperData,
+  QuotaState,
+} from "../../base";
+import { BaseContract } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PoolQuotaKeeperStateHuman } from "../../types";
+import { AddressMap, formatBNvalue, percentFmt } from "../../utils";
+
+const abi = iPoolQuotaKeeperV310Abi;
+type abi = typeof abi;
+
+export class PoolQuotaKeeperV310Contract
+  extends BaseContract<abi>
+  implements IBaseContract
+{
+  public readonly decimals: number;
+  public readonly quotas: AddressMap<QuotaState>;
+
+  constructor(sdk: GearboxSDK, pool: PoolData, pqk: PoolQuotaKeeperData) {
+    super(sdk, {
+      ...pqk.baseParams,
+      name: `PoolQuotaKeeper(${pool.name})`,
+      abi,
+    });
+
+    this.decimals = pool.decimals;
+
+    this.quotas = new AddressMap(
+      pqk.quotas.map(q => {
+        return [q.token, q];
+      }),
+      "quotas",
+    );
+  }
+
+  public override stateHuman(raw = true): PoolQuotaKeeperStateHuman {
+    return {
+      ...super.stateHuman(raw),
+      quotas: this.quotas.entries().reduce(
+        (acc, [address, params]) => ({
+          ...acc,
+          [this.labelAddress(address)]: {
+            rate: percentFmt(params.rate, raw),
+            quotaIncreaseFee: percentFmt(params.quotaIncreaseFee, raw),
+            totalQuoted: formatBNvalue(
+              params.totalQuoted,
+              this.decimals,
+              2,
+              raw,
+            ),
+            limit: formatBNvalue(params.limit, this.decimals, 2, raw),
+            isActive: params.isActive,
+          },
+        }),
+        {},
+      ),
+    };
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "AddCreditManager":
+      case "AddQuotaToken":
+      case "SetGauge":
+      case "SetQuotaIncreaseFee":
+      case "SetTokenLimit":
+      case "UpdateQuota":
+      case "UpdateTokenQuotaRate":
+        this.dirty = true;
+        break;
+    }
+  }
+}

package/src/sdk/market/pool/PoolSuite.ts

@@ -0,0 +1,76 @@
+import type { Address } from "viem";
+
+import type { MarketData } from "../../base";
+import { SDKConstruct } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PoolSuiteStateHuman } from "../../types";
+import createInterestRateModel from "./createInterestRateModel";
+import createPool from "./createPool";
+import createPoolQuotaKeeper from "./createPoolQuotaKeeper";
+import createRateKeeper from "./createRateKeeper";
+import { GaugeContract } from "./GaugeContract";
+import { LinearInterestRateModelContract } from "./LinearInterestRateModelContract";
+import type {
+  IInterestRateModelContract,
+  IRateKeeperContract,
+  PoolContract,
+  PoolQuotaKeeperContract,
+} from "./types";
+
+export class PoolSuite extends SDKConstruct {
+  public readonly pool: PoolContract;
+  public readonly pqk: PoolQuotaKeeperContract;
+  public readonly rateKeeper: IRateKeeperContract;
+  public readonly interestRateModel: IInterestRateModelContract;
+
+  constructor(sdk: GearboxSDK, data: MarketData) {
+    super(sdk);
+    this.pool = createPool(sdk, data.pool);
+    this.pqk = createPoolQuotaKeeper(sdk, data.pool, data.poolQuotaKeeper);
+    this.rateKeeper = createRateKeeper(sdk, data.pool, data.rateKeeper);
+    this.interestRateModel = createInterestRateModel(
+      sdk,
+      data.interestRateModel,
+    );
+  }
+
+  public get gauge(): GaugeContract {
+    if (this.rateKeeper instanceof GaugeContract) {
+      return this.rateKeeper;
+    }
+    throw new Error(
+      "Rate keeper is not a gauge, but a " + this.rateKeeper.contractType,
+    );
+  }
+
+  public get linearModel(): LinearInterestRateModelContract {
+    if (this.interestRateModel instanceof LinearInterestRateModelContract) {
+      return this.interestRateModel;
+    }
+    throw new Error(
+      `Interest rate model is not a linear model, but a ${this.interestRateModel.contractType}`,
+    );
+  }
+
+  public get underlying(): Address {
+    return this.pool.underlying;
+  }
+
+  override get dirty(): boolean {
+    return (
+      this.pool.dirty ||
+      this.gauge.dirty ||
+      this.pqk.dirty ||
+      this.interestRateModel.dirty
+    );
+  }
+
+  public stateHuman(raw = true): PoolSuiteStateHuman {
+    return {
+      pool: this.pool.stateHuman(raw),
+      poolQuotaKeeper: this.pqk.stateHuman(raw),
+      interestRateModel: this.interestRateModel.stateHuman(raw),
+      rateKeeper: this.rateKeeper.stateHuman(raw),
+    };
+  }
+}