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

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

@@ -0,0 +1,139 @@
+import type {
+  Address,
+  ContractEventName,
+  DecodeFunctionDataReturnType,
+  Log,
+} from "viem";
+
+import { iCreditConfiguratorV310Abi } from "../../../abi/v310";
+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 { RampEvent } from "./CreditConfiguratorV300Contract";
+import type { ICreditConfiguratorContract } from "./types";
+
+const abi = iCreditConfiguratorV310Abi;
+type abi = typeof abi;
+
+export class CreditConfiguratorV310Contract
+  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 "AddCollateralToken":
+      case "AllowAdapter":
+      case "AllowToken":
+      case "CreditConfiguratorUpgraded":
+      case "ForbidAdapter":
+      case "ForbidToken":
+      case "ScheduleTokenLiquidationThresholdRamp":
+      case "SetBorrowingLimits":
+      case "SetCreditFacade":
+      case "SetExpirationDate":
+      case "SetLossPolicy":
+      case "SetMaxDebtPerBlockMultiplier":
+      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 [
+          feeLiquidation,
+          liquidationPremium,
+          feeLiquidationExpired,
+          liquidationPremiumExpired,
+        ] = params.args;
+        return [
+          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;
+    }
+  }
+}

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

@@ -0,0 +1,206 @@
+import type {
+  Address,
+  ContractEventName,
+  DecodeFunctionDataReturnType,
+  Log,
+} from "viem";
+import { encodeFunctionData } from "viem";
+
+import { iPausableAbi } from "../../../abi/iPausable";
+import {
+  iCreditFacadeV300Abi,
+  iCreditFacadeV300MulticallAbi,
+} from "../../../abi/v300";
+import type { CreditFacadeState, CreditManagerData } from "../../base";
+import { BaseContract } from "../../base";
+import { ADDRESS_0X0 } from "../../constants";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { CreditFacadeStateHuman, MultiCall, RawTx } from "../../types";
+import { fmtBinaryMask, formatBNvalue } from "../../utils";
+import type { OnDemandPriceUpdate } from "../oracle";
+
+const abi = [
+  ...iCreditFacadeV300Abi,
+  ...iCreditFacadeV300MulticallAbi,
+  ...iPausableAbi,
+] as const;
+type abi = typeof abi;
+
+// Augmenting contract class with interface of compressor data object
+export interface CreditFacadeV300Contract
+  extends Omit<CreditFacadeState, "baseParams">,
+    BaseContract<abi> {}
+
+export class CreditFacadeV300Contract extends BaseContract<abi> {
+  public readonly underlying: Address;
+
+  constructor(
+    sdk: GearboxSDK,
+    { creditFacade, creditManager }: CreditManagerData,
+  ) {
+    const { baseParams, ...rest } = creditFacade;
+    super(sdk, {
+      ...baseParams,
+      name: `CreditFacadeV3(${creditManager.name})`,
+      abi,
+    });
+    Object.assign(this, rest);
+    this.underlying = creditManager.underlying;
+  }
+
+  public override stateHuman(raw?: boolean): CreditFacadeStateHuman {
+    const decimals = this.sdk.tokensMeta.decimals(this.underlying);
+    return {
+      ...super.stateHuman(raw),
+      expirable: this.expirable,
+      isDegenMode: this.degenNFT !== ADDRESS_0X0,
+      degenNFT: this.labelAddress(this.degenNFT),
+      expirationDate: this.expirationDate,
+      maxDebtPerBlockMultiplier: this.maxDebtPerBlockMultiplier,
+      botList: this.labelAddress(this.botList),
+      minDebt: formatBNvalue(this.minDebt, decimals),
+      maxDebt: formatBNvalue(this.maxDebt, decimals),
+      currentCumulativeLoss: "0", // TODO
+      maxCumulativeLoss: "0", // TODO
+      forbiddenTokenMask: fmtBinaryMask(this.forbiddenTokenMask),
+      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 "AddCollateral":
+      case "CloseCreditAccount":
+      case "DecreaseDebt":
+      case "Execute":
+      case "FinishMultiCall":
+      case "IncreaseDebt":
+      case "LiquidateCreditAccount":
+      case "OpenCreditAccount":
+      case "StartMultiCall":
+      case "WithdrawCollateral":
+        this.dirty = true;
+        break;
+    }
+  }
+
+  public encodeOnDemandPriceUpdates(
+    updates: OnDemandPriceUpdate[],
+  ): MultiCall[] {
+    return updates.map(u => ({
+      target: this.address,
+      callData: encodeFunctionData({
+        abi: iCreditFacadeV300MulticallAbi,
+        functionName: "onDemandPriceUpdate",
+        args: [u.token, u.reserve, u.data],
+      }),
+    }));
+  }
+
+  public liquidateCreditAccount(
+    ca: Address,
+    to: Address,
+    calls: MultiCall[],
+  ): RawTx {
+    return this.createRawTx({
+      functionName: "liquidateCreditAccount",
+      args: [ca, to, calls],
+    });
+  }
+
+  public closeCreditAccount(ca: Address, calls: MultiCall[]): RawTx {
+    return this.createRawTx({
+      functionName: "closeCreditAccount",
+      args: [ca, calls],
+    });
+  }
+
+  public multicall(ca: Address, calls: MultiCall[]): RawTx {
+    return this.createRawTx({
+      functionName: "multicall",
+      args: [ca, calls],
+    });
+  }
+
+  public openCreditAccount(
+    to: Address,
+    calls: MultiCall[],
+    referralCode: bigint,
+  ): RawTx {
+    return this.createRawTx({
+      functionName: "openCreditAccount",
+      args: [to, calls, referralCode],
+    });
+  }
+
+  public parseFunctionParams(
+    params: DecodeFunctionDataReturnType<abi>,
+  ): string[] | undefined {
+    switch (params.functionName) {
+      case "openCreditAccount": {
+        const [onBehalfOf, calls, referralCode] = params.args;
+        return [
+          this.labelAddress(onBehalfOf),
+          this.sdk.parseMultiCall([...calls]).join(","),
+          `${referralCode}`,
+        ];
+      }
+      case "closeCreditAccount": {
+        const [creditAccount, calls] = params.args;
+        return [
+          this.labelAddress(creditAccount),
+          this.sdk.parseMultiCall([...calls]).join(","),
+        ];
+      }
+      case "liquidateCreditAccount": {
+        const [creditAccount, to, calls] = params.args;
+        return [
+          this.labelAddress(creditAccount),
+          this.labelAddress(to),
+          this.sdk.parseMultiCall([...calls]).join(","),
+        ];
+      }
+      case "setBotPermissions": {
+        const [creditAccount, bot, permissions] = params.args;
+        return [
+          this.labelAddress(creditAccount),
+          this.labelAddress(bot),
+          fmtBinaryMask(permissions),
+        ];
+      }
+      case "storeExpectedBalances": {
+        const [deltas] = params.args;
+        return [
+          deltas
+            .map(({ token, amount }) => {
+              return (
+                this.labelAddress(token) +
+                ": " +
+                this.sdk.tokensMeta.formatBN(token, amount)
+              );
+            })
+            .join(","),
+        ];
+      }
+
+      default:
+        return undefined;
+    }
+  }
+}

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

@@ -0,0 +1,190 @@
+import type {
+  Address,
+  ContractEventName,
+  DecodeFunctionDataReturnType,
+  Log,
+} from "viem";
+import { encodeFunctionData } from "viem";
+
+import { iPausableAbi } from "../../../abi/iPausable";
+import {
+  iCreditFacadeMulticallV310Abi,
+  iCreditFacadeV310Abi,
+} from "../../../abi/v310";
+import type { CreditFacadeState, CreditManagerData } from "../../base";
+import { BaseContract } from "../../base";
+import { ADDRESS_0X0 } from "../../constants";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { CreditFacadeStateHuman, MultiCall, RawTx } from "../../types";
+import { fmtBinaryMask, formatBNvalue } from "../../utils";
+import type { OnDemandPriceUpdate } from "../oracle";
+
+const abi = [
+  ...iCreditFacadeV310Abi,
+  ...iCreditFacadeMulticallV310Abi,
+  ...iPausableAbi,
+] as const;
+type abi = typeof abi;
+
+// Augmenting contract class with interface of compressor data object
+export interface CreditFacadeV310Contract
+  extends Omit<CreditFacadeState, "baseParams">,
+    BaseContract<abi> {}
+
+export class CreditFacadeV310Contract extends BaseContract<abi> {
+  public readonly underlying: Address;
+
+  constructor(
+    sdk: GearboxSDK,
+    { creditFacade, creditManager }: CreditManagerData,
+  ) {
+    const { baseParams, ...rest } = creditFacade;
+    super(sdk, {
+      ...baseParams,
+      name: `CreditFacadeV310(${creditManager.name})`,
+      abi,
+    });
+    Object.assign(this, rest);
+    this.underlying = creditManager.underlying;
+  }
+
+  public override stateHuman(raw?: boolean): CreditFacadeStateHuman {
+    const decimals = this.sdk.tokensMeta.decimals(this.underlying);
+    return {
+      ...super.stateHuman(raw),
+      expirable: this.expirable,
+      isDegenMode: this.degenNFT !== ADDRESS_0X0,
+      degenNFT: this.labelAddress(this.degenNFT),
+      expirationDate: this.expirationDate,
+      maxDebtPerBlockMultiplier: this.maxDebtPerBlockMultiplier,
+      botList: this.labelAddress(this.botList),
+      minDebt: formatBNvalue(this.minDebt, decimals),
+      maxDebt: formatBNvalue(this.maxDebt, decimals),
+      currentCumulativeLoss: "0", // TODO
+      maxCumulativeLoss: "0", // TODO
+      forbiddenTokenMask: fmtBinaryMask(this.forbiddenTokenMask),
+      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 "AddCollateral":
+      case "CloseCreditAccount":
+      case "Execute":
+      case "FinishMultiCall":
+      case "LiquidateCreditAccount":
+      case "OpenCreditAccount":
+      case "PartiallyLiquidateCreditAccount":
+      case "StartMultiCall":
+      case "WithdrawCollateral":
+      case "WithdrawPhantomToken":
+        this.dirty = true;
+        break;
+    }
+  }
+
+  public encodeOnDemandPriceUpdates(
+    updates: OnDemandPriceUpdate[],
+  ): MultiCall[] {
+    return [
+      {
+        target: this.address,
+        callData: encodeFunctionData({
+          abi: iCreditFacadeMulticallV310Abi,
+          functionName: "onDemandPriceUpdates",
+          args: [
+            updates.map(u => ({
+              priceFeed: u.priceFeed,
+              data: u.data,
+            })),
+          ],
+        }),
+      },
+    ];
+  }
+
+  public liquidateCreditAccount(
+    ca: Address,
+    to: Address,
+    calls: MultiCall[],
+  ): RawTx {
+    return this.createRawTx({
+      functionName: "liquidateCreditAccount",
+      args: [ca, to, calls],
+    });
+  }
+
+  public closeCreditAccount(ca: Address, calls: MultiCall[]): RawTx {
+    return this.createRawTx({
+      functionName: "closeCreditAccount",
+      args: [ca, calls],
+    });
+  }
+
+  public multicall(ca: Address, calls: MultiCall[]): RawTx {
+    return this.createRawTx({
+      functionName: "multicall",
+      args: [ca, calls],
+    });
+  }
+
+  public openCreditAccount(
+    to: Address,
+    calls: MultiCall[],
+    referralCode: bigint,
+  ): RawTx {
+    return this.createRawTx({
+      functionName: "openCreditAccount",
+      args: [to, calls, referralCode],
+    });
+  }
+
+  public parseFunctionParams(
+    params: DecodeFunctionDataReturnType<abi>,
+  ): string[] | undefined {
+    switch (params.functionName) {
+      case "openCreditAccount": {
+        const [onBehalfOf, calls, referralCode] = params.args;
+        return [
+          this.labelAddress(onBehalfOf),
+          this.sdk.parseMultiCall([...calls]).join(","),
+          `${referralCode}`,
+        ];
+      }
+      case "closeCreditAccount": {
+        const [creditAccount, calls] = params.args;
+        return [
+          this.labelAddress(creditAccount),
+          this.sdk.parseMultiCall([...calls]).join(","),
+        ];
+      }
+      case "liquidateCreditAccount": {
+        const [creditAccount, to, calls] = params.args;
+        return [
+          this.labelAddress(creditAccount),
+          this.labelAddress(to),
+          this.sdk.parseMultiCall([...calls]).join(","),
+        ];
+      }
+      default:
+        return undefined;
+    }
+  }
+}

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

@@ -0,0 +1,122 @@
+import type { Address, ContractEventName, Log } from "viem";
+
+import { iCreditManagerV300Abi } from "../../../abi/v300";
+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";
+
+type abi = typeof iCreditManagerV300Abi;
+const abi = iCreditManagerV300Abi;
+
+// Augmenting contract class with interface of compressor data object
+export interface CreditManagerV300Contract
+  extends Omit<
+      CreditManagerState,
+      "baseParams" | "collateralTokens" | "liquidationThresholds"
+    >,
+    BaseContract<abi> {}
+
+export class CreditManagerV300Contract
+  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: `CreditManagerV300(${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;
+    }
+  }
+}