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

package/src/sdk/accounts/index.ts

@@ -0,0 +1 @@
+export * from "./CreditAccountsService";

package/src/sdk/base/AddressLabeller.ts

@@ -0,0 +1,35 @@
+import type { Address } from "viem";
+
+import { NOT_DEPLOYED } from "../constants";
+import { AddressMap } from "../utils";
+import type { IAddressLabeller } from "./IAddressLabeller";
+
+/**
+ * Helper class to be used during transition from v3 to v3.1
+ */
+export class AddressLabeller implements IAddressLabeller {
+  #labels = new AddressMap<string>(undefined, "addressLabeller");
+
+  public set(
+    address: Address,
+    label: string | ((oldLabel?: string) => string),
+  ): void {
+    if (address === NOT_DEPLOYED) {
+      return;
+    }
+    if (typeof label === "string") {
+      this.#labels.upsert(address, label);
+    } else {
+      this.#labels.upsert(address, label(this.#labels.get(address)));
+    }
+  }
+
+  public get(address: Address): string {
+    const label = this.#labels.get(address);
+    return label ? `${address} [${label}]` : address;
+  }
+
+  public get all(): Record<Address, string> {
+    return this.#labels.asRecord();
+  }
+}

package/src/sdk/base/BaseContract.ts

@@ -0,0 +1,237 @@
+import type {
+  Abi,
+  AbiFunction,
+  Address,
+  Client,
+  ContractEventName,
+  ContractFunctionName,
+  DecodeFunctionDataReturnType,
+  EncodeFunctionDataParameters,
+  GetContractReturnType,
+  Hex,
+  Log,
+} from "viem";
+import { decodeFunctionData, getContract, isHex } from "viem";
+
+import { errorAbis } from "../../abi/errors";
+import { iVersionAbi } from "../../abi/iVersion";
+import { ADDRESS_0X0 } from "../constants";
+import type { GearboxSDK } from "../GearboxSDK";
+import type { BaseContractStateHuman, ILogger, RawTx } from "../types";
+import {
+  bytes32ToString,
+  childLogger,
+  createRawTx,
+  json_stringify,
+} from "../utils";
+import type { IAddressLabeller } from "./IAddressLabeller";
+import { SDKConstruct } from "./SDKConstruct";
+
+export interface BaseContractOptions<abi extends Abi | readonly unknown[]> {
+  abi: abi;
+  addr: Address;
+  name?: string;
+  version?: number | bigint;
+  contractType?: string;
+}
+
+export interface IBaseContract {
+  address: Address;
+  contractType: string;
+  version: number;
+  name: string;
+  dirty: boolean;
+}
+
+export abstract class BaseContract<abi extends Abi | readonly unknown[]>
+  extends SDKConstruct
+  implements IBaseContract
+{
+  public readonly contract: GetContractReturnType<
+    abi,
+    { public: Client },
+    Address
+  >;
+  public readonly abi: abi;
+  public readonly logger?: ILogger;
+  public readonly contractType: string;
+  public version: number;
+
+  #name: string;
+  #address: Address;
+
+  constructor(sdk: GearboxSDK, args: BaseContractOptions<abi>) {
+    super(sdk);
+    this.abi = args.abi;
+    this.#address = args.addr;
+
+    this.contract = getContract({
+      address: this.address,
+      // add exceptions for better error decoding
+      abi: [...this.abi, ...errorAbis],
+      client: {
+        public: sdk.provider.publicClient,
+      },
+    }) as any;
+    this.version = Number(args.version || 0);
+    this.contractType = args.contractType ?? "";
+    if (isHex(this.contractType)) {
+      this.contractType = bytes32ToString(this.contractType);
+    }
+    this.name = this.#name = args.name || this.contractType || this.#address;
+    this.logger = childLogger(this.name, sdk.logger);
+
+    // register contract by address: this is used for system-wide call parsing
+    sdk.contracts.upsert(this.address, this);
+  }
+
+  public get address(): Address {
+    return this.#address;
+  }
+
+  public set address(address: Address) {
+    if (this.#address !== ADDRESS_0X0) {
+      throw new Error(`Address can't be changed, currently: ${this.#address}`);
+    }
+    this.#address = address;
+    this.addressLabels.set(address, this.#name);
+  }
+
+  public test_setAddress(address: Address) {
+    this.#address = address;
+    this.addressLabels.set(address, this.#name);
+  }
+
+  public get name(): string {
+    return this.#name;
+  }
+
+  public set name(name: string) {
+    this.#name = name;
+    if (this.#address !== ADDRESS_0X0) {
+      this.addressLabels.set(this.#address, name);
+    }
+  }
+
+  // TODO: unused
+  public stateHuman(_ = true): BaseContractStateHuman {
+    return {
+      address: this.sdk.provider.addressLabels.get(this.address),
+      version: this.version,
+      contractType: this.contractType,
+    };
+  }
+
+  /**
+   * Updates (or not) contract's internal state from event
+   * @param _log
+   */
+  public processLog(
+    _log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {}
+
+  /**
+   * Converts contract calldata to some human-friendly string
+   * @param calldata
+   * @returns
+   */
+  public parseFunctionData(calldata: Hex): string {
+    const decoded = decodeFunctionData({
+      abi: this.abi,
+      data: calldata,
+    });
+
+    const abiItem = (this.abi as Array<AbiFunction>).find(
+      abiItem =>
+        abiItem!.name === decoded.functionName && abiItem!.type === "function",
+    );
+
+    if (!abiItem) {
+      return `Unknown function: ${decoded.functionName}`;
+    }
+
+    let paramsHuman: Array<string>;
+    let humanParams = this.parseFunctionParams(decoded);
+    if (humanParams) {
+      paramsHuman = humanParams.map((value, i) => {
+        return `${abiItem.inputs[i].name}: ${value}`;
+      });
+    } else if (Array.isArray(decoded.args)) {
+      paramsHuman = decoded.args.map((value, i) => {
+        return `${abiItem.inputs[i].name}: ${abiItem.inputs[i].type === "address" ? this.addressLabels.get(value) : abiItem.inputs[i].type.startsWith("tuple") ? json_stringify(value) : value}`;
+      });
+    } else {
+      paramsHuman = Object.entries(decoded.args || {}).map(
+        ([key, value]) => `${key}: ${value}`,
+      );
+    }
+
+    return `${this.name}.${decoded.functionName}({${paramsHuman.join(", ")}})`;
+  }
+
+  /**
+   * Return args and function name from calldata
+   * @param calldata
+   * @returns
+   */
+  public parseFunctionDataToObject(calldata: Hex) {
+    const decoded = decodeFunctionData({
+      abi: this.abi,
+      data: calldata,
+    });
+    return decoded;
+  }
+
+  public parseFunctionParams(
+    _params: DecodeFunctionDataReturnType<abi>,
+  ): Array<string> | undefined {
+    return undefined;
+  }
+
+  public async getVersion(): Promise<number> {
+    this.version = Number(
+      await this.sdk.provider.publicClient.readContract({
+        abi: iVersionAbi,
+        functionName: "version",
+        address: this.address,
+      }),
+    );
+
+    return this.version;
+  }
+
+  public createRawTx<
+    functionName extends ContractFunctionName<abi> | undefined = undefined,
+  >(
+    parameters: Omit<EncodeFunctionDataParameters<abi, functionName>, "abi"> & {
+      description?: string;
+    },
+  ): RawTx {
+    const { description: argsDescription } = parameters;
+
+    const tx = createRawTx<abi, functionName>(
+      this.address,
+      {
+        ...parameters,
+        abi: this.abi,
+      } as EncodeFunctionDataParameters<abi, functionName>,
+      argsDescription,
+    );
+
+    tx.description = argsDescription || this.parseFunctionData(tx.callData); // `${this.name}.${parameters.functionName}(${argsDescription || (args && args.length > 0) ? args!.join(", ") : ""})`;
+
+    return tx;
+  }
+
+  protected get addressLabels(): IAddressLabeller {
+    return this.sdk.provider.addressLabels;
+  }
+}

package/src/sdk/base/IAddressLabeller.ts

@@ -0,0 +1,13 @@
+import type { Address } from "viem";
+
+/**
+ * Helper interface to ease v3.1 refactoring and migration from static methods
+ */
+export interface IAddressLabeller {
+  set: (
+    address: Address,
+    label: string | ((oldLabel?: string) => string),
+  ) => void;
+  get: (address: Address) => string;
+  all: Record<Address, string>;
+}

package/src/sdk/base/PlaceholderContract.ts

@@ -0,0 +1,12 @@
+import type { GearboxSDK } from "../GearboxSDK";
+import type { BaseContractOptions } from "./BaseContract";
+import { BaseContract } from "./BaseContract";
+
+const abi = [] as unknown[];
+type abi = typeof abi;
+
+export class PlaceholderContract extends BaseContract<abi> {
+  constructor(sdk: GearboxSDK, args: Omit<BaseContractOptions<abi>, "abi">) {
+    super(sdk, { ...args, abi });
+  }
+}

package/src/sdk/base/SDKConstruct.ts

@@ -0,0 +1,35 @@
+import type { Address } from "viem";
+
+import type { Provider } from "../chain";
+import type { GearboxSDK } from "../GearboxSDK";
+
+export class SDKConstruct {
+  public readonly sdk: GearboxSDK;
+  /**
+   * Indicates that contract state needs to be updated
+   */
+  #dirty = false;
+
+  constructor(sdk: GearboxSDK) {
+    this.sdk = sdk;
+  }
+
+  public get provider(): Provider {
+    return this.sdk.provider;
+  }
+
+  /**
+   * Indicates that contract state needs to be updated
+   */
+  public get dirty(): boolean {
+    return this.#dirty;
+  }
+
+  protected set dirty(value: boolean) {
+    this.#dirty = value;
+  }
+
+  protected labelAddress(address: Address): string {
+    return this.provider.addressLabels.get(address);
+  }
+}

package/src/sdk/base/TokensMeta.ts

@@ -0,0 +1,45 @@
+import type { Address } from "viem";
+
+import type { Asset } from "../router";
+import { AddressMap, formatBN } from "../utils";
+import type { TokenMetaData } from "./types";
+
+export class TokensMeta extends AddressMap<TokenMetaData> {
+  public symbol(token: Address): string {
+    return this.mustGet(token).symbol;
+  }
+
+  public decimals(token: Address): number {
+    return this.mustGet(token).decimals;
+  }
+
+  public formatBN(asset: Asset, precision?: number): string;
+  public formatBN(
+    token: Address,
+    amount: number | bigint | string | undefined,
+    precision?: number,
+  ): string;
+  public formatBN(
+    arg0: Asset | Address,
+    arg1: number | bigint | string | undefined,
+    arg2?: number,
+  ): string {
+    const token = typeof arg0 === "object" ? arg0.token : arg0;
+    const amount = typeof arg0 === "object" ? arg0.balance : arg1;
+    const precision =
+      typeof arg0 === "object" ? (arg1 as number | undefined) : arg2;
+    return formatBN(amount, this.decimals(token), precision);
+  }
+
+  public findBySymbol(symbol: string): TokenMetaData | undefined {
+    return this.values().find(v => v.symbol === symbol);
+  }
+
+  public mustFindBySymbol(symbol: string): TokenMetaData {
+    const meta = this.findBySymbol(symbol);
+    if (!meta) {
+      throw new Error(`cannot find token meta for symbol '${symbol}'`);
+    }
+    return meta;
+  }
+}

package/src/sdk/base/index.ts

@@ -0,0 +1,6 @@
+export * from "./AddressLabeller";
+export * from "./BaseContract";
+export * from "./PlaceholderContract";
+export * from "./SDKConstruct";
+export * from "./TokensMeta";
+export * from "./types";

package/src/sdk/base/types.ts

@@ -0,0 +1,102 @@
+import type {
+  AbiParametersToPrimitiveTypes,
+  ExtractAbiFunction,
+} from "abitype";
+import type { Address, Hex } from "viem";
+
+import type {
+  iCreditAccountCompressorAbi,
+  iGaugeCompressorAbi,
+  iMarketCompressorAbi,
+  iPeripheryCompressorAbi,
+  iRewardsCompressorAbi,
+} from "../../abi/compressors";
+
+export type Unarray<A> = A extends readonly unknown[] ? Unarray<A[number]> : A;
+
+export interface BaseParams {
+  addr: Address;
+  version: bigint;
+  contractType: Hex;
+  serializedParams: Hex;
+}
+
+export interface BaseState {
+  baseParams: BaseParams;
+}
+
+export type MarketFilter = AbiParametersToPrimitiveTypes<
+  ExtractAbiFunction<typeof iMarketCompressorAbi, "getMarkets">["inputs"]
+>[0];
+
+export type CreditAccountData = Unarray<
+  AbiParametersToPrimitiveTypes<
+    ExtractAbiFunction<
+      typeof iCreditAccountCompressorAbi,
+      "getCreditAccountData"
+    >["outputs"]
+  >
+>;
+
+export type RewardInfo = Unarray<
+  AbiParametersToPrimitiveTypes<
+    ExtractAbiFunction<typeof iRewardsCompressorAbi, "getRewards">["outputs"]
+  >
+>;
+
+export type MarketData = Unarray<
+  AbiParametersToPrimitiveTypes<
+    ExtractAbiFunction<typeof iMarketCompressorAbi, "getMarkets">["outputs"]
+  >
+>;
+
+export type ZapperData = Unarray<
+  AbiParametersToPrimitiveTypes<
+    ExtractAbiFunction<typeof iPeripheryCompressorAbi, "getZappers">["outputs"]
+  >
+>;
+
+export type GaugeData = Unarray<
+  AbiParametersToPrimitiveTypes<
+    ExtractAbiFunction<typeof iGaugeCompressorAbi, "getGauge">["outputs"]
+  >
+>;
+
+export type ConnectedBotData = Unarray<
+  AbiParametersToPrimitiveTypes<
+    ExtractAbiFunction<
+      typeof iPeripheryCompressorAbi,
+      "getConnectedBots"
+    >["outputs"]
+  >
+>;
+
+export type BotData = Unarray<
+  AbiParametersToPrimitiveTypes<
+    ExtractAbiFunction<typeof iPeripheryCompressorAbi, "getBots">["outputs"]
+  >
+>;
+
+export type CreditManagerData = Unarray<MarketData["creditManagers"]>;
+
+export type CreditManagerState = CreditManagerData["creditManager"];
+export type CreditFacadeState = CreditManagerData["creditFacade"];
+export type CreditConfiguratorState = CreditManagerData["creditConfigurator"];
+export type AdapterData = Unarray<CreditManagerData["adapters"]>;
+export type TokenMetaData = Unarray<MarketData["tokens"]>;
+export type PoolData = MarketData["pool"];
+export type PoolQuotaKeeperData = MarketData["poolQuotaKeeper"];
+export type QuotaState = Unarray<PoolQuotaKeeperData["quotas"]>;
+export type RateKeeperData = MarketData["rateKeeper"];
+export type PriceOracleData = MarketData["priceOracleData"];
+export type PriceFeedMapEntry = Unarray<PriceOracleData["priceFeedMapping"]>;
+export type PriceFeedTreeNode = Unarray<PriceOracleData["priceFeedStructure"]>;
+export type CreditManagerDebtParams = Unarray<
+  PoolData["creditManagerDebtParams"]
+>;
+
+export enum VotingContractStatus {
+  NOT_ALLOWED = 0,
+  ALLOWED = 1,
+  UNVOTE_ONLY = 2,
+}

package/src/sdk/bots/BotsService.ts

@@ -0,0 +1,92 @@
+import { type Address, parseAbi } from "viem";
+
+import { SDKConstruct } from "../base";
+import type { BotBaseType, BotDataPayload, BotDetailedType } from "./utils";
+
+export type BotAddresses = Partial<Record<BotDetailedType, Address>>;
+
+const iPartialLiquidationBotV3Abi = parseAbi([
+  "function minHealthFactor() external view returns (uint16)",
+  "function maxHealthFactor() external view returns (uint16)",
+  "function premiumScaleFactor() external view returns (uint16)",
+  "function feeScaleFactor() external view returns (uint16)",
+]);
+
+export class BotsService extends SDKConstruct {
+  /**
+   * Returns bots data payload
+   * @param addresses
+   * @returns
+   */
+  public async getBotsData(addresses: BotAddresses) {
+    const addressesList = Object.entries(addresses) as Array<
+      [BotDetailedType, Address]
+    >;
+
+    const BOT_INFO_LENGTH = 4;
+    const infoResp = (await this.provider.publicClient.multicall({
+      allowFailure: false,
+      contracts: addressesList
+        .map(([, address]) => [
+          {
+            address,
+            abi: iPartialLiquidationBotV3Abi,
+            functionName: "minHealthFactor",
+            args: [],
+          },
+          {
+            address,
+            abi: iPartialLiquidationBotV3Abi,
+            functionName: "maxHealthFactor",
+            args: [],
+          },
+          {
+            address,
+            abi: iPartialLiquidationBotV3Abi,
+            functionName: "premiumScaleFactor",
+            args: [],
+          },
+          {
+            address,
+            abi: iPartialLiquidationBotV3Abi,
+            functionName: "feeScaleFactor",
+            args: [],
+          },
+        ])
+        .flat(1),
+    })) as Array<number>;
+
+    const currentType: BotBaseType = "liquidationProtection";
+    const bots = addressesList.reduce<
+      Record<BotBaseType, Array<BotDataPayload>>
+    >(
+      (acc, [type, address], index) => {
+        const from = index * BOT_INFO_LENGTH;
+        const to = (index + 1) * BOT_INFO_LENGTH;
+
+        const [
+          minHealthFactor,
+          maxHealthFactor,
+          premiumScaleFactor,
+          feeScaleFactor,
+        ] = infoResp.slice(from, to);
+
+        acc[currentType].push({
+          address,
+          baseType: currentType,
+          detailedType: type,
+
+          minHealthFactor,
+          maxHealthFactor,
+          premiumScaleFactor,
+          feeScaleFactor,
+        });
+
+        return acc;
+      },
+      { liquidationProtection: [] },
+    );
+
+    return bots;
+  }
+}

package/src/sdk/bots/index.ts

@@ -0,0 +1,2 @@
+export * from "./BotsService";
+export * from "./utils";

package/src/sdk/bots/utils.ts

@@ -0,0 +1,19 @@
+import type { Address } from "viem";
+
+export type BotBaseType = "liquidationProtection";
+export type LiquidationBotType =
+  | "deleverageBotPegged"
+  | "deleverageBotLV"
+  | "deleverageBotHV";
+
+export type BotDetailedType = LiquidationBotType;
+
+export interface BotDataPayload {
+  baseType: BotBaseType;
+  detailedType: BotDetailedType;
+  address: Address;
+  minHealthFactor: number;
+  maxHealthFactor: number;
+  premiumScaleFactor: number;
+  feeScaleFactor: number;
+}