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

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

@@ -0,0 +1,144 @@
+import type {
+  ContractEventName,
+  DecodeFunctionDataReturnType,
+  Log,
+} from "viem";
+
+import { iPausableAbi } from "../../../abi/iPausable";
+import { iPoolV300Abi } from "../../../abi/v300";
+import type { CreditManagerDebtParams, PoolData } from "../../base";
+import { BaseContract } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PoolStateHuman } from "../../types";
+import { AddressMap, formatBN, formatBNvalue, percentFmt } from "../../utils";
+
+const abi = [...iPoolV300Abi, ...iPausableAbi] as const;
+type abi = typeof abi;
+
+// Augmenting contract class with interface of compressor data object
+export interface PoolV300Contract
+  extends Omit<PoolData, "baseParams" | "creditManagerDebtParams">,
+    BaseContract<abi> {}
+
+export class PoolV300Contract extends BaseContract<abi> {
+  public readonly creditManagerDebtParams: AddressMap<CreditManagerDebtParams>;
+
+  constructor(sdk: GearboxSDK, data: PoolData) {
+    const { baseParams, creditManagerDebtParams, ...rest } = data;
+    super(sdk, {
+      ...data.baseParams,
+      name: `PoolV3(${data.name})`,
+      abi,
+    });
+    Object.assign(this, rest);
+    this.creditManagerDebtParams = new AddressMap(
+      creditManagerDebtParams.map(p => [p.creditManager, p]),
+    );
+    // Put diesel token into tokens meta
+    sdk.tokensMeta.upsert(data.baseParams.addr, {
+      addr: data.baseParams.addr,
+      decimals: data.decimals,
+      name: data.name,
+      symbol: data.symbol,
+    });
+  }
+
+  public override stateHuman(raw = true): PoolStateHuman {
+    return {
+      ...super.stateHuman(raw),
+      underlying: this.labelAddress(this.underlying),
+      symbol: this.symbol,
+      name: this.name,
+      decimals: this.decimals,
+      availableLiquidity: formatBNvalue(
+        this.availableLiquidity,
+        this.decimals,
+        2,
+        raw,
+      ),
+      expectedLiquidity: formatBNvalue(
+        this.expectedLiquidity,
+        this.decimals,
+        2,
+        raw,
+      ),
+      totalBorrowed: formatBNvalue(this.totalBorrowed, this.decimals, 2, raw),
+      totalDebtLimit: formatBNvalue(this.totalDebtLimit, this.decimals, 2, raw),
+      creditManagerDebtParams: Object.fromEntries(
+        this.creditManagerDebtParams
+          .values()
+          .map(({ creditManager, borrowed, limit, available }) => [
+            this.labelAddress(creditManager),
+            {
+              borrowed: formatBNvalue(borrowed, this.decimals, 2, raw),
+              limit: formatBNvalue(limit, this.decimals, 2, raw),
+              availableToBorrow: formatBNvalue(
+                available,
+                this.decimals,
+                2,
+                raw,
+              ),
+            },
+          ]),
+      ),
+      totalSupply: formatBNvalue(this.totalSupply, this.decimals, 2, raw),
+      supplyRate: `${formatBNvalue(this.supplyRate, 25, 2, raw)}%`,
+      baseInterestIndex: `${formatBNvalue(this.totalSupply, 25, 2, raw)}%`,
+      baseInterestRate: `${formatBNvalue(this.totalSupply, 25, 2, raw)}%`,
+      withdrawFee: percentFmt(this.withdrawFee),
+      lastBaseInterestUpdate: this.lastBaseInterestUpdate.toString(),
+      baseInterestIndexLU: this.lastBaseInterestUpdate.toString(),
+      isPaused: this.isPaused,
+    };
+  }
+
+  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 "AddCreditManager":
+      case "Approval":
+      case "Borrow":
+      case "Deposit":
+      case "IncurUncoveredLoss":
+      case "Refer":
+      case "Repay":
+      case "SetCreditManagerDebtLimit":
+      case "SetInterestRateModel":
+      case "SetPoolQuotaKeeper":
+      case "SetTotalDebtLimit":
+      case "SetWithdrawFee":
+      case "Transfer":
+      case "Withdraw":
+        this.dirty = true;
+        break;
+    }
+  }
+
+  public parseFunctionParams(
+    params: DecodeFunctionDataReturnType<abi>,
+  ): Array<string> | undefined {
+    switch (params.functionName) {
+      case "deposit": {
+        const [amount, onBehalfOf] = params.args;
+        return [formatBN(amount, this.decimals), this.labelAddress(onBehalfOf)];
+      }
+      default:
+        return undefined;
+    }
+  }
+}

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

@@ -0,0 +1,144 @@
+import type {
+  ContractEventName,
+  DecodeFunctionDataReturnType,
+  Log,
+} from "viem";
+
+import { iPausableAbi } from "../../../abi/iPausable";
+import { iPoolV310Abi } from "../../../abi/v310";
+import type { CreditManagerDebtParams, PoolData } from "../../base";
+import { BaseContract } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { PoolStateHuman } from "../../types";
+import { AddressMap, formatBN, formatBNvalue, percentFmt } from "../../utils";
+
+const abi = [...iPoolV310Abi, ...iPausableAbi] as const;
+type abi = typeof abi;
+
+// Augmenting contract class with interface of compressor data object
+export interface PoolV310Contract
+  extends Omit<PoolData, "baseParams" | "creditManagerDebtParams">,
+    BaseContract<abi> {}
+
+export class PoolV310Contract extends BaseContract<abi> {
+  public readonly creditManagerDebtParams: AddressMap<CreditManagerDebtParams>;
+
+  constructor(sdk: GearboxSDK, data: PoolData) {
+    const { baseParams, creditManagerDebtParams, ...rest } = data;
+    super(sdk, {
+      ...data.baseParams,
+      name: `PoolV3(${data.name})`,
+      abi,
+    });
+    Object.assign(this, rest);
+    this.creditManagerDebtParams = new AddressMap(
+      creditManagerDebtParams.map(p => [p.creditManager, p]),
+    );
+    // Put diesel token into tokens meta
+    sdk.tokensMeta.upsert(data.baseParams.addr, {
+      addr: data.baseParams.addr,
+      decimals: data.decimals,
+      name: data.name,
+      symbol: data.symbol,
+    });
+  }
+
+  public override stateHuman(raw = true): PoolStateHuman {
+    return {
+      ...super.stateHuman(raw),
+      underlying: this.labelAddress(this.underlying),
+      symbol: this.symbol,
+      name: this.name,
+      decimals: this.decimals,
+      availableLiquidity: formatBNvalue(
+        this.availableLiquidity,
+        this.decimals,
+        2,
+        raw,
+      ),
+      expectedLiquidity: formatBNvalue(
+        this.expectedLiquidity,
+        this.decimals,
+        2,
+        raw,
+      ),
+      totalBorrowed: formatBNvalue(this.totalBorrowed, this.decimals, 2, raw),
+      totalDebtLimit: formatBNvalue(this.totalDebtLimit, this.decimals, 2, raw),
+      creditManagerDebtParams: Object.fromEntries(
+        this.creditManagerDebtParams
+          .values()
+          .map(({ creditManager, borrowed, limit, available }) => [
+            this.labelAddress(creditManager),
+            {
+              borrowed: formatBNvalue(borrowed, this.decimals, 2, raw),
+              limit: formatBNvalue(limit, this.decimals, 2, raw),
+              availableToBorrow: formatBNvalue(
+                available,
+                this.decimals,
+                2,
+                raw,
+              ),
+            },
+          ]),
+      ),
+      totalSupply: formatBNvalue(this.totalSupply, this.decimals, 2, raw),
+      supplyRate: `${formatBNvalue(this.supplyRate, 25, 2, raw)}%`,
+      baseInterestIndex: `${formatBNvalue(this.totalSupply, 25, 2, raw)}%`,
+      baseInterestRate: `${formatBNvalue(this.totalSupply, 25, 2, raw)}%`,
+      withdrawFee: percentFmt(this.withdrawFee),
+      lastBaseInterestUpdate: this.lastBaseInterestUpdate.toString(),
+      baseInterestIndexLU: this.lastBaseInterestUpdate.toString(),
+      isPaused: this.isPaused,
+    };
+  }
+
+  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 "AddCreditManager":
+      case "Approval":
+      case "Borrow":
+      case "Deposit":
+      case "IncurUncoveredLoss":
+      case "Refer":
+      case "Repay":
+      case "SetCreditManagerDebtLimit":
+      case "SetInterestRateModel":
+      case "SetPoolQuotaKeeper":
+      case "SetTotalDebtLimit":
+      case "SetWithdrawFee":
+      case "Transfer":
+      case "Withdraw":
+        this.dirty = true;
+        break;
+    }
+  }
+
+  public parseFunctionParams(
+    params: DecodeFunctionDataReturnType<abi>,
+  ): Array<string> | undefined {
+    switch (params.functionName) {
+      case "deposit": {
+        const [amount, onBehalfOf] = params.args;
+        return [formatBN(amount, this.decimals), this.labelAddress(onBehalfOf)];
+      }
+      default:
+        return undefined;
+    }
+  }
+}

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

@@ -0,0 +1,73 @@
+import type { ContractEventName, Log } from "viem";
+import { decodeAbiParameters } from "viem";
+
+import { iTumblerV310Abi } from "../../../abi/v310";
+import type { PoolData, RateKeeperData } from "../../base";
+import { BaseContract } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { TumblerStateHuman } from "../../types";
+import { AddressMap, formatDuration, percentFmt } from "../../utils";
+import type { IRateKeeperContract } from "./types";
+
+const abi = iTumblerV310Abi;
+type abi = typeof abi;
+
+export class TumblerContract
+  extends BaseContract<abi>
+  implements IRateKeeperContract
+{
+  public readonly epochLength: bigint;
+  public readonly rates: AddressMap<number>;
+
+  constructor(sdk: GearboxSDK, pool: PoolData, tumbler: RateKeeperData) {
+    super(sdk, {
+      ...tumbler.baseParams,
+      name: `Tumbler(${pool.name})`,
+      abi,
+    });
+
+    const [epochLength, tokens_, rates_] = decodeAbiParameters(
+      [
+        { name: "epochLength", type: "uint256" },
+        { name: "tokens", type: "address[]" },
+        { name: "rates", type: "uint16[]" },
+      ],
+      tumbler.baseParams.serializedParams,
+    );
+    this.epochLength = epochLength;
+    this.rates = new AddressMap(tokens_.map((t, i) => [t, rates_[i]]));
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "AddToken":
+      case "SetRate":
+        this.dirty = true;
+        break;
+    }
+  }
+
+  public override stateHuman(raw?: boolean): TumblerStateHuman {
+    return {
+      ...super.stateHuman(raw),
+      epochLength: formatDuration(Number(this.epochLength), raw),
+      rates: this.rates.entries().reduce(
+        (acc, [token, rate]) => ({
+          ...acc,
+          [this.labelAddress(token)]: percentFmt(rate, raw),
+        }),
+        {},
+      ),
+    };
+  }
+}

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

@@ -0,0 +1,33 @@
+import type { BaseState } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { bytes32ToString } from "../../utils";
+import { LinearInterestRateModelContract } from "./LinearInterestRateModelContract";
+import type {
+  IInterestRateModelContract,
+  InterestRateModelType,
+} from "./types";
+
+export default function createInterestRateModel(
+  sdk: GearboxSDK,
+  data: BaseState,
+): IInterestRateModelContract {
+  const { addr, contractType } = data.baseParams;
+
+  if (sdk.interestRateModels.has(addr)) {
+    return sdk.interestRateModels.mustGet(
+      addr,
+    ) as any as IInterestRateModelContract;
+  } else {
+    const modelType = bytes32ToString(contractType) as InterestRateModelType;
+    switch (modelType) {
+      case "IRM::LINEAR": {
+        const linearModel = new LinearInterestRateModelContract(sdk, data);
+        sdk.interestRateModels.insert(addr, linearModel as any);
+        return linearModel;
+      }
+      default: {
+        throw new Error(`Unknown interest rate model type: ${modelType}`);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,19 @@
+import type { PoolData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { PoolV300Contract } from "./PoolV300Contract";
+import { PoolV310Contract } from "./PoolV310Contract";
+import type { PoolContract } from "./types";
+
+export default function createPool(
+  sdk: GearboxSDK,
+  data: PoolData,
+): PoolContract {
+  const v = data.baseParams.version;
+  if (v >= 300n && v < 310n) {
+    return new PoolV300Contract(sdk, data);
+  }
+  if (v === 310n) {
+    return new PoolV310Contract(sdk, data);
+  }
+  throw new Error(`Unsupported pool version ${v}`);
+}

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

@@ -0,0 +1,20 @@
+import type { PoolData, PoolQuotaKeeperData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { PoolQuotaKeeperV300Contract } from "./PoolQuotaKeeperV300Contract";
+import { PoolQuotaKeeperV310Contract } from "./PoolQuotaKeeperV310Contract";
+import type { PoolQuotaKeeperContract } from "./types";
+
+export default function createPoolQuotaKeeper(
+  sdk: GearboxSDK,
+  pool: PoolData,
+  pqk: PoolQuotaKeeperData,
+): PoolQuotaKeeperContract {
+  const v = pqk.baseParams.version;
+  if (v >= 300n && v < 310n) {
+    return new PoolQuotaKeeperV300Contract(sdk, pool, pqk);
+  }
+  if (v === 310n) {
+    return new PoolQuotaKeeperV310Contract(sdk, pool, pqk);
+  }
+  throw new Error(`Unsupported pool quota keeper version ${v}`);
+}

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

@@ -0,0 +1,25 @@
+import type { PoolData, RateKeeperData } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { bytes32ToString } from "../../utils";
+import { GaugeContract } from "./GaugeContract";
+import { TumblerContract } from "./TumblerContract";
+import type { IRateKeeperContract, RateKeeperType } from "./types";
+
+export default function createRateKeeper(
+  sdk: GearboxSDK,
+  pool: PoolData,
+  data: RateKeeperData,
+): IRateKeeperContract {
+  const rateKeeperType = bytes32ToString(
+    data.baseParams.contractType,
+  ) as RateKeeperType;
+
+  switch (rateKeeperType) {
+    case "RATE_KEEPER::GAUGE":
+      return new GaugeContract(sdk, pool, data);
+    case "RATE_KEEPER::TUMBLER":
+      return new TumblerContract(sdk, pool, data);
+    default:
+      throw new Error(`Unknown rate keeper type: ${rateKeeperType}`);
+  }
+}

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

@@ -0,0 +1,6 @@
+export * from "./GaugeContract";
+export * from "./LinearInterestRateModelContract";
+export * from "./PoolQuotaKeeperV300Contract";
+export * from "./PoolSuite";
+export * from "./PoolV300Contract";
+export * from "./types";

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

@@ -0,0 +1,28 @@
+import type { IBaseContract } from "../../base";
+import type {
+  InterestRateModelStateHuman,
+  RateKeeperStateHuman,
+} from "../../types";
+import type { AddressMap } from "../../utils";
+import type { PoolQuotaKeeperV300Contract } from "./PoolQuotaKeeperV300Contract";
+import type { PoolQuotaKeeperV310Contract } from "./PoolQuotaKeeperV310Contract";
+import type { PoolV300Contract } from "./PoolV300Contract";
+import type { PoolV310Contract } from "./PoolV310Contract";
+
+export type RateKeeperType = `RATE_KEEPER::${string}`;
+export type InterestRateModelType = `IRM::${string}`;
+
+export interface IRateKeeperContract extends IBaseContract {
+  readonly rates: AddressMap<number>;
+
+  stateHuman: (raw?: boolean) => RateKeeperStateHuman;
+}
+
+export interface IInterestRateModelContract extends IBaseContract {
+  stateHuman: (raw?: boolean) => InterestRateModelStateHuman;
+}
+
+export type PoolContract = PoolV300Contract | PoolV310Contract;
+export type PoolQuotaKeeperContract =
+  | PoolQuotaKeeperV300Contract
+  | PoolQuotaKeeperV310Contract;

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

@@ -0,0 +1,71 @@
+import type { Abi, Address, UnionOmit } from "viem";
+import { decodeAbiParameters, hexToBytes } from "viem";
+
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { LPPriceFeedStateHuman } from "../../types/state-human";
+import {
+  AbstractPriceFeedContract,
+  type PriceFeedConstructorArgs,
+} from "./AbstractPriceFeed";
+
+const LOWER_BOUND_FACTOR = 99n;
+
+export abstract class AbstractLPPriceFeedContract<
+  const abi extends Abi | readonly unknown[],
+> extends AbstractPriceFeedContract<abi> {
+  public readonly lpContract: Address;
+  public readonly lpToken: Address;
+  public readonly lowerBound: bigint;
+  public readonly upperBound: bigint;
+
+  constructor(sdk: GearboxSDK, args: PriceFeedConstructorArgs<abi>) {
+    super(sdk, { ...args, decimals: 8 });
+    this.hasLowerBoundCap = true;
+    const decoder = decodeAbiParameters(
+      [
+        { type: "address", name: "lpToken" },
+        { type: "address", name: "lpContract" },
+        { type: "uint256", name: "lowerBound" },
+        { type: "uint256", name: "upperBound" },
+        // { type: "bool", name: "updateBoundsAllowed" },
+        // { type: "uint40", name: "lastBoundsUpdate" },
+        { type: "int256", name: "aggregatePrice" },
+        { type: "uint256", name: "lPExchangeRate" },
+        { type: "uint256", name: "scale" },
+      ],
+      hexToBytes(args.baseParams.serializedParams),
+    );
+
+    this.lpToken = decoder[0];
+    this.lpContract = decoder[1];
+    this.lowerBound = decoder[2];
+    this.upperBound = decoder[3];
+  }
+
+  abstract getValue(): Promise<bigint>;
+
+  async getLowerBound(): Promise<bigint> {
+    const value = await this.getValue();
+    const lowerBound = AbstractLPPriceFeedContract.toLowerBound(value);
+    this.logger?.debug(
+      `Lowerbound for ${this.labelAddress(this.address)}: ${lowerBound}`,
+    );
+    return lowerBound;
+  }
+
+  static toLowerBound(value: bigint): bigint {
+    return (value * LOWER_BOUND_FACTOR) / 100n;
+  }
+
+  public override stateHuman(
+    raw?: boolean,
+  ): UnionOmit<LPPriceFeedStateHuman, "stalenessPeriod"> {
+    return {
+      ...super.stateHuman(raw),
+      lpContract: this.lpContract,
+      lpToken: this.lpToken,
+      lowerBound: this.lowerBound,
+      upperBound: this.upperBound,
+    };
+  }
+}