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

package/src/sdk/core/address-provider/AbstractAddressProviderContract.ts

@@ -0,0 +1,101 @@
+import { type Abi, type Address, hexToString, isHex, stringToHex } from "viem";
+
+import { BaseContract } from "../../base";
+import type { BaseContractOptions } from "../../base/BaseContract";
+import { NO_VERSION } from "../../constants";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { AddressProviderV3StateHuman } from "../../types";
+import type { AddressProviderState } from "./types";
+
+export default abstract class AbstractAddressProviderContract<
+  abi extends Abi | readonly unknown[],
+> extends BaseContract<abi> {
+  #addresses: Record<string, Record<number, Address>> = {};
+  #latest: Record<string, number> = {};
+
+  constructor(
+    sdk: GearboxSDK,
+    args: BaseContractOptions<abi>,
+    addresses: Record<string, Record<number, Address>> = {},
+  ) {
+    super(sdk, args);
+    this.#addresses = addresses;
+  }
+
+  protected setInternalAddress(key: string, address: Address, version: number) {
+    let k = isHex(key) ? hexToString(key, { size: 32 }) : key;
+    if (!this.#addresses[k]) {
+      this.#addresses[k] = {};
+    }
+    this.#addresses[k][version] = address;
+    if (!this.#latest[k] || version > this.#latest[key]) {
+      this.#latest[k] = version;
+    }
+    this.logger?.debug(`Set address for ${k}@${version} to ${address}`);
+  }
+
+  public getAddress(contract: string, version = NO_VERSION): Address {
+    if (!this.#addresses[contract]) {
+      throw new Error(`Address ${contract}, version: ${version} not found`);
+    }
+
+    const result = this.#addresses[contract][version];
+    if (!result) {
+      throw new Error(`Address ${contract}, version: ${version} not found`);
+    }
+
+    return result;
+  }
+
+  public getLatestVersion(contract: string): Address {
+    if (!this.#latest[contract]) {
+      throw new Error(`Latest version for ${contract} not found`);
+    }
+
+    this.logger?.debug(
+      `Latest version found for ${contract} : ${this.#latest[contract]}`,
+    );
+
+    return this.getAddress(contract, this.#latest[contract]);
+  }
+
+  public get state(): AddressProviderState {
+    return {
+      baseParams: {
+        addr: this.address,
+        version: BigInt(this.version),
+        contractType: stringToHex(this.contractType, { size: 32 }),
+        serializedParams: "0x0",
+      },
+      addresses: this.#addresses,
+    };
+  }
+
+  public override stateHuman(raw = true): AddressProviderV3StateHuman {
+    return {
+      ...super.stateHuman(raw),
+      addresses: Object.entries(this.#addresses)
+        .map(([key, value]) => {
+          return Object.entries(value).map(([version, address]) => {
+            return {
+              key,
+              version,
+              address: this.sdk.provider.addressLabels.get(address),
+            };
+          });
+        })
+        .reduce(
+          (acc, vals) => {
+            for (const val of vals) {
+              if (!acc[val.key]) {
+                acc[val.key] = {};
+              }
+              acc[val.key][val.version as unknown as number] = val.address;
+            }
+            return acc;
+          },
+          {} as Record<string, Record<number, string>>,
+        ),
+    };
+  }
+}

package/src/sdk/core/address-provider/AddressProviderV3Contract.ts

@@ -0,0 +1,105 @@
+import type {
+  Address,
+  ContractEventName,
+  DecodeFunctionDataReturnType,
+  Log,
+} from "viem";
+import { bytesToString, getAbiItem, parseEventLogs, toBytes } from "viem";
+
+import { iAddressProviderV300Abi } from "../../../abi/v300";
+import { ADDRESS_PROVIDER_BLOCK } from "../../constants";
+import type { GearboxSDK } from "../../GearboxSDK";
+import AbstractAddressProviderContract from "./AbstractAddressProviderContract";
+import type { IAddressProviderContract } from "./types";
+
+const abi = iAddressProviderV300Abi;
+type abi = typeof abi;
+
+export class AddressProviderContractV3
+  extends AbstractAddressProviderContract<abi>
+  implements IAddressProviderContract
+{
+  constructor(
+    sdk: GearboxSDK,
+    address: Address,
+    addresses: Record<string, Record<number, Address>> = {},
+  ) {
+    super(
+      sdk,
+      {
+        addr: address,
+        name: "AddressProviderV3",
+        abi,
+        version: 3_00,
+      },
+      addresses,
+    );
+  }
+
+  public parseFunctionParams(
+    params: DecodeFunctionDataReturnType<abi>,
+  ): Array<string> | undefined {
+    switch (params.functionName) {
+      case "setAddress": {
+        if (params.args.length !== 3) {
+          const [key, saveVersion] = params.args;
+          return [key, `${saveVersion}`];
+        }
+        const [key, value, saveVersion] = params.args;
+        return [bytesToString(toBytes(key)), value, `${saveVersion}`];
+      }
+      default:
+        return undefined;
+    }
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "SetAddress": {
+        const { args } = parseEventLogs({
+          abi: this.abi,
+          eventName: "SetAddress",
+          logs: [log],
+        })[0];
+        const { key, version } = args;
+
+        this.setInternalAddress(
+          key,
+          log.args.value as Address,
+          Number(version),
+        );
+        break;
+      }
+      default:
+        this.logger?.warn(`Unknown event: ${log.eventName}`);
+        break;
+    }
+  }
+
+  public async syncState(blockNumber?: bigint): Promise<void> {
+    const events = await this.sdk.provider.publicClient.getLogs({
+      address: this.address,
+      event: getAbiItem({ abi: this.abi, name: "SetAddress" }),
+      fromBlock: ADDRESS_PROVIDER_BLOCK[this.sdk.provider.networkType],
+      toBlock: blockNumber,
+      strict: true,
+    });
+    for (const event of events) {
+      this.setInternalAddress(
+        event.args.key,
+        event.args.value,
+        Number(event.args.version),
+      );
+    }
+  }
+}

package/src/sdk/core/address-provider/AddressProviderV3_1Contract.ts

@@ -0,0 +1,92 @@
+import type {
+  Address,
+  ContractEventName,
+  DecodeFunctionDataReturnType,
+  Log,
+} from "viem";
+import { bytesToString, parseEventLogs, toBytes } from "viem";
+
+import { iAddressProviderV310Abi } from "../../../abi/v310";
+import type { GearboxSDK } from "../../GearboxSDK";
+import AbstractAddressProviderContract from "./AbstractAddressProviderContract";
+import type { IAddressProviderContract } from "./types";
+
+const abi = iAddressProviderV310Abi;
+type abi = typeof abi;
+
+export class AddressProviderContractV3_1
+  extends AbstractAddressProviderContract<abi>
+  implements IAddressProviderContract
+{
+  constructor(
+    sdk: GearboxSDK,
+    address: Address,
+    addresses: Record<string, Record<number, Address>> = {},
+  ) {
+    super(
+      sdk,
+      {
+        addr: address,
+        name: "AddressProviderV3_1",
+        abi,
+        version: 3_10,
+      },
+      addresses,
+    );
+  }
+
+  public parseFunctionParams(
+    params: DecodeFunctionDataReturnType<abi>,
+  ): Array<string> | undefined {
+    switch (params.functionName) {
+      case "setAddress": {
+        if (params.args.length !== 3) {
+          const [key, saveVersion] = params.args;
+          return [key, `${saveVersion}`];
+        }
+        const [key, value, saveVersion] = params.args;
+        return [bytesToString(toBytes(key)), value, `${saveVersion}`];
+      }
+      default:
+        return undefined;
+    }
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "SetAddress": {
+        const { args } = parseEventLogs({
+          abi: this.abi,
+          eventName: "SetAddress",
+          logs: [log],
+        })[0];
+        const { key, ver, value } = args;
+
+        this.setInternalAddress(key, value, Number(ver));
+        break;
+      }
+      default:
+        this.logger?.warn(`Unknown event: ${log.eventName}`);
+        break;
+    }
+  }
+
+  public async syncState(blockNumber?: bigint): Promise<void> {
+    const entries = await this.contract.read.getAllEntries({
+      blockNumber,
+    });
+    for (const { key, ver, value } of entries) {
+      this.setInternalAddress(key, value, Number(ver));
+    }
+  }
+}

package/src/sdk/core/address-provider/getAddressProvider.ts

@@ -0,0 +1,45 @@
+import type { Address } from "viem";
+
+import { iVersionAbi } from "../../../abi/iVersion";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { AddressProviderContractV3_1 } from "./AddressProviderV3_1Contract";
+import { AddressProviderContractV3 } from "./AddressProviderV3Contract";
+import type { AddressProviderState, IAddressProviderContract } from "./types";
+
+export interface GetAddressProviderOptions {
+  version?: number;
+  state?: AddressProviderState;
+}
+
+export async function getAddressProvider(
+  sdk: GearboxSDK,
+  address: Address,
+  options?: GetAddressProviderOptions,
+): Promise<IAddressProviderContract> {
+  const addr = options?.state?.baseParams.addr ?? address;
+  let v = options?.state?.baseParams.version ?? options?.version;
+  if (!v) {
+    const vv = await sdk.provider.publicClient.readContract({
+      address: addr,
+      abi: iVersionAbi,
+      functionName: "version",
+    });
+    v = Number(vv);
+  }
+  switch (v) {
+    case 3_00:
+      return new AddressProviderContractV3(
+        sdk,
+        addr,
+        options?.state?.addresses,
+      );
+    case 3_10:
+      return new AddressProviderContractV3_1(
+        sdk,
+        addr,
+        options?.state?.addresses,
+      );
+    default:
+      throw new Error(`Unsupported address provider version: ${v}`);
+  }
+}

package/src/sdk/core/address-provider/index.ts

@@ -0,0 +1,4 @@
+export * from "./AddressProviderV3_1Contract";
+export * from "./AddressProviderV3Contract";
+export * from "./getAddressProvider";
+export * from "./types";

package/src/sdk/core/address-provider/types.ts

@@ -0,0 +1,17 @@
+import type { Address } from "viem";
+
+import type { BaseParams, IBaseContract } from "../../base";
+import type { AddressProviderV3StateHuman } from "../../types";
+
+export interface AddressProviderState {
+  baseParams: BaseParams;
+  addresses: Record<string, Record<number, Address>>;
+}
+
+export interface IAddressProviderContract extends IBaseContract {
+  state: AddressProviderState;
+  getAddress: (contract: string, version?: number) => Address;
+  getLatestVersion: (contract: string) => Address;
+  syncState: (blockNumber: bigint) => Promise<void>;
+  stateHuman: (raw?: boolean) => AddressProviderV3StateHuman;
+}

package/src/sdk/core/index.ts

@@ -0,0 +1,3 @@
+export * from "./address-provider";
+export * from "./BotListV3Contract";
+export * from "./GearStakingV3Contract";

package/src/sdk/gauges/GaugeStakingService.ts

@@ -0,0 +1,100 @@
+import type { Address } from "viem";
+
+import { iGaugeCompressorAbi } from "../../abi/compressors";
+import { SDKConstruct } from "../base";
+import { AP_GAUGE_COMPRESSOR } from "../constants";
+import type { GearboxSDK } from "../GearboxSDK";
+import type { GaugeStakingDataPayload } from "./utils";
+
+export class GaugeStakingService extends SDKConstruct {
+  #compressor: Address;
+
+  constructor(sdk: GearboxSDK) {
+    super(sdk);
+
+    this.#compressor =
+      this.sdk.addressProvider.getLatestVersion(AP_GAUGE_COMPRESSOR);
+  }
+
+  /**
+   * Returns voting state for wallet
+   * @param wallet
+   * @returns
+   */
+  public async getGaugeStakingData(
+    wallet: Address,
+  ): Promise<GaugeStakingDataPayload> {
+    const marketFilter = this.sdk.marketRegister.marketFilter;
+    if (!marketFilter) throw new Error("market filter is not set");
+
+    const [gauges, availableBalance, totalBalance, withdrawableAmounts, epoch] =
+      await this.provider.publicClient.multicall({
+        allowFailure: false,
+        contracts: [
+          {
+            abi: iGaugeCompressorAbi,
+            address: this.#compressor,
+            functionName: "getGauges",
+            args: [marketFilter, wallet],
+          },
+          {
+            address: this.sdk.gearStakingContract.address,
+            abi: this.sdk.gearStakingContract.abi,
+            functionName: "availableBalance",
+            args: [wallet],
+          },
+          {
+            address: this.sdk.gearStakingContract.address,
+            abi: this.sdk.gearStakingContract.abi,
+            functionName: "balanceOf",
+            args: [wallet],
+          },
+          {
+            address: this.sdk.gearStakingContract.address,
+            abi: this.sdk.gearStakingContract.abi,
+            functionName: "getWithdrawableAmounts",
+            args: [wallet],
+          },
+          {
+            address: this.sdk.gearStakingContract.address,
+            abi: this.sdk.gearStakingContract.abi,
+            functionName: "getCurrentEpoch",
+            args: [],
+          },
+        ],
+      });
+
+    return {
+      availableBalance,
+      totalBalance,
+      epoch,
+      withdrawableAmounts: {
+        withdrawableNow: withdrawableAmounts[0],
+        withdrawableInEpochs: withdrawableAmounts[1],
+      },
+
+      voteParams: gauges.reduce<GaugeStakingDataPayload["voteParams"]>(
+        (acc, v) => {
+          acc[v.addr] = {
+            pool: v.pool,
+            gauge: v.addr,
+            quotaParams: v.quotaParams.reduce<
+              GaugeStakingDataPayload["voteParams"][Address]["quotaParams"]
+            >((acc, q) => {
+              acc[q.token] = {
+                token: q.token,
+                stakerVotesLpSide: q.stakerVotesLpSide,
+                stakerVotesCaSide: q.stakerVotesCaSide,
+              };
+
+              return acc;
+            }, {}),
+          };
+
+          return acc;
+        },
+        {},
+      ),
+    };
+  }
+}

package/src/sdk/gauges/index.ts

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

package/src/sdk/gauges/utils.ts

@@ -0,0 +1,25 @@
+import type { Address } from "viem";
+
+interface UserVote {
+  token: Address;
+  stakerVotesLpSide: bigint;
+  stakerVotesCaSide: bigint;
+}
+
+interface GaugeVoteInfo {
+  pool: Address;
+  gauge: Address;
+  quotaParams: Record<Address, UserVote>;
+}
+
+export interface GaugeStakingDataPayload {
+  availableBalance: bigint;
+  totalBalance: bigint;
+  epoch: number;
+  withdrawableAmounts: {
+    withdrawableNow: bigint;
+    withdrawableInEpochs: readonly [bigint, bigint, bigint, bigint];
+  };
+
+  voteParams: Record<Address, GaugeVoteInfo>;
+}

package/src/sdk/index.ts

@@ -0,0 +1,17 @@
+export * from "./abi";
+export * from "./accounts";
+export * from "./base";
+export * from "./bots";
+export * from "./chain";
+export * from "./constants";
+export * from "./core";
+export * from "./gauges";
+export * from "./GearboxSDK";
+export * from "./market";
+export * from "./plugins";
+export * from "./router";
+export * from "./sdk-gov-legacy";
+export * from "./sdk-legacy";
+export * from "./types";
+export * from "./utils";
+export * from "./utils/viem";

package/src/sdk/market/MarketConfiguratorContract.ts

@@ -0,0 +1,78 @@
+import {
+  type Address,
+  type ContractEventName,
+  type Log,
+  stringToHex,
+} from "viem";
+
+import { iMarketConfiguratorV310Abi } from "../../abi/v310";
+import { BaseContract } from "../base";
+import type { PeripheryContract } from "../constants";
+import { AP_MARKET_CONFIGURATOR } from "../constants";
+import type { GearboxSDK } from "../GearboxSDK";
+
+const abi = iMarketConfiguratorV310Abi;
+type abi = typeof abi;
+
+export class MarketConfiguratorContract extends BaseContract<abi> {
+  #curatorName?: string;
+
+  constructor(sdk: GearboxSDK, address: Address) {
+    super(sdk, {
+      abi,
+      addr: address,
+      contractType: AP_MARKET_CONFIGURATOR,
+      version: 0,
+    });
+  }
+
+  public async loadCuratorName(): Promise<void> {
+    this.#curatorName = await this.sdk.provider.publicClient.readContract({
+      address: this.address,
+      abi: this.abi,
+      functionName: "curatorName",
+    });
+    this.sdk.provider.addressLabels.set(
+      this.address,
+      "Market configurator " + this.#curatorName,
+    );
+  }
+
+  public async getPeripheryContract(
+    contract: PeripheryContract,
+  ): Promise<Address> {
+    const resp = await this.sdk.provider.publicClient.readContract({
+      address: this.address,
+      abi: this.abi,
+      functionName: "getPeripheryContracts",
+      args: [stringToHex(contract, { size: 32 })],
+    });
+    if (resp.length === 0) {
+      throw new Error(`periphery contract ${contract} not found`);
+    }
+    return resp[0];
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      // case "DeployDegenNFT":
+      // case "SetName":
+      // case "SetPriceFeedFromStore":
+      // case "SetReservePriceFeedFromStore":
+      case "ShutdownMarket":
+      case "CreateMarket":
+        this.dirty = true;
+        break;
+    }
+  }
+}