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

package/src/sdk/sdk-legacy/types/IMulticall3.ts

@@ -0,0 +1,242 @@
+/// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// IMulticall3
+/// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+export const iMulticall3Abi = [
+  {
+    type: "function",
+    inputs: [
+      {
+        name: "calls",
+        internalType: "struct IMulticall3.Call[]",
+        type: "tuple[]",
+        components: [
+          { name: "target", internalType: "address", type: "address" },
+          { name: "callData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    name: "aggregate",
+    outputs: [
+      { name: "blockNumber", internalType: "uint256", type: "uint256" },
+      { name: "returnData", internalType: "bytes[]", type: "bytes[]" },
+    ],
+    stateMutability: "payable",
+  },
+  {
+    type: "function",
+    inputs: [
+      {
+        name: "calls",
+        internalType: "struct IMulticall3.Call3[]",
+        type: "tuple[]",
+        components: [
+          { name: "target", internalType: "address", type: "address" },
+          { name: "allowFailure", internalType: "bool", type: "bool" },
+          { name: "callData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    name: "aggregate3",
+    outputs: [
+      {
+        name: "returnData",
+        internalType: "struct IMulticall3.Result[]",
+        type: "tuple[]",
+        components: [
+          { name: "success", internalType: "bool", type: "bool" },
+          { name: "returnData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    stateMutability: "payable",
+  },
+  {
+    type: "function",
+    inputs: [
+      {
+        name: "calls",
+        internalType: "struct IMulticall3.Call3Value[]",
+        type: "tuple[]",
+        components: [
+          { name: "target", internalType: "address", type: "address" },
+          { name: "allowFailure", internalType: "bool", type: "bool" },
+          { name: "value", internalType: "uint256", type: "uint256" },
+          { name: "callData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    name: "aggregate3Value",
+    outputs: [
+      {
+        name: "returnData",
+        internalType: "struct IMulticall3.Result[]",
+        type: "tuple[]",
+        components: [
+          { name: "success", internalType: "bool", type: "bool" },
+          { name: "returnData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    stateMutability: "payable",
+  },
+  {
+    type: "function",
+    inputs: [
+      {
+        name: "calls",
+        internalType: "struct IMulticall3.Call[]",
+        type: "tuple[]",
+        components: [
+          { name: "target", internalType: "address", type: "address" },
+          { name: "callData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    name: "blockAndAggregate",
+    outputs: [
+      { name: "blockNumber", internalType: "uint256", type: "uint256" },
+      { name: "blockHash", internalType: "bytes32", type: "bytes32" },
+      {
+        name: "returnData",
+        internalType: "struct IMulticall3.Result[]",
+        type: "tuple[]",
+        components: [
+          { name: "success", internalType: "bool", type: "bool" },
+          { name: "returnData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    stateMutability: "payable",
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "getBasefee",
+    outputs: [{ name: "basefee", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [{ name: "blockNumber", internalType: "uint256", type: "uint256" }],
+    name: "getBlockHash",
+    outputs: [{ name: "blockHash", internalType: "bytes32", type: "bytes32" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "getBlockNumber",
+    outputs: [
+      { name: "blockNumber", internalType: "uint256", type: "uint256" },
+    ],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "getChainId",
+    outputs: [{ name: "chainid", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "getCurrentBlockCoinbase",
+    outputs: [{ name: "coinbase", internalType: "address", type: "address" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "getCurrentBlockDifficulty",
+    outputs: [{ name: "difficulty", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "getCurrentBlockGasLimit",
+    outputs: [{ name: "gaslimit", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "getCurrentBlockTimestamp",
+    outputs: [{ name: "timestamp", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [{ name: "addr", internalType: "address", type: "address" }],
+    name: "getEthBalance",
+    outputs: [{ name: "balance", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "getLastBlockHash",
+    outputs: [{ name: "blockHash", internalType: "bytes32", type: "bytes32" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "requireSuccess", internalType: "bool", type: "bool" },
+      {
+        name: "calls",
+        internalType: "struct IMulticall3.Call[]",
+        type: "tuple[]",
+        components: [
+          { name: "target", internalType: "address", type: "address" },
+          { name: "callData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    name: "tryAggregate",
+    outputs: [
+      {
+        name: "returnData",
+        internalType: "struct IMulticall3.Result[]",
+        type: "tuple[]",
+        components: [
+          { name: "success", internalType: "bool", type: "bool" },
+          { name: "returnData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    stateMutability: "payable",
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "requireSuccess", internalType: "bool", type: "bool" },
+      {
+        name: "calls",
+        internalType: "struct IMulticall3.Call[]",
+        type: "tuple[]",
+        components: [
+          { name: "target", internalType: "address", type: "address" },
+          { name: "callData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    name: "tryBlockAndAggregate",
+    outputs: [
+      { name: "blockNumber", internalType: "uint256", type: "uint256" },
+      { name: "blockHash", internalType: "bytes32", type: "bytes32" },
+      {
+        name: "returnData",
+        internalType: "struct IMulticall3.Result[]",
+        type: "tuple[]",
+        components: [
+          { name: "success", internalType: "bool", type: "bool" },
+          { name: "returnData", internalType: "bytes", type: "bytes" },
+        ],
+      },
+    ],
+    stateMutability: "payable",
+  },
+] as const;

package/src/sdk/sdk-legacy/types/IOffchainOracle.ts

@@ -0,0 +1,31 @@
+/// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// IOffchainOracle
+/// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+export const iOffchainOracleAbi = [
+  {
+    type: "function",
+    inputs: [
+      { name: "srcToken", internalType: "address", type: "address" },
+      { name: "dstToken", internalType: "address", type: "address" },
+      { name: "useWrappers", internalType: "bool", type: "bool" },
+    ],
+    name: "getRate",
+    outputs: [
+      { name: "weightedRate", internalType: "uint256", type: "uint256" },
+    ],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "srcToken", internalType: "address", type: "address" },
+      { name: "useSrcWrappers", internalType: "bool", type: "bool" },
+    ],
+    name: "getRateToEth",
+    outputs: [
+      { name: "weightedRate", internalType: "uint256", type: "uint256" },
+    ],
+    stateMutability: "view",
+  },
+] as const;

package/src/sdk/sdk-legacy/types/index.ts

@@ -0,0 +1,11 @@
+export * from "./IAirdropDistributor";
+export * from "./IBaseRewardPool";
+export * from "./IDataCompressorV3";
+export * from "./IDegenDistributor";
+export * from "./IERC20Permit";
+export * from "./IERC20ZapperDeposits";
+export * from "./IETHZapperDeposits";
+export * from "./IFarmingPool";
+export * from "./IInterestRateModel";
+export * from "./IMulticall3";
+export * from "./IOffchainOracle";

package/src/sdk/sdk-legacy/utils/formatter.ts

@@ -0,0 +1,46 @@
+import Decimal from "decimal.js-light";
+
+import { LEVERAGE_DECIMALS, PERCENTAGE_FACTOR } from "../../constants";
+import { toBigInt } from "../../utils";
+
+export type BigNumberish = bigint | number | string;
+
+export function rayToNumber(num: BigNumberish): number {
+  return Number(toBigInt(num) / 10n ** 21n) / 1000000;
+}
+
+export function toSignificant(
+  num: bigint,
+  decimals: number,
+  precision = 6,
+): string {
+  if (num === 1n) return "0";
+  const divider = new Decimal(10).toPower(decimals);
+  const number = new Decimal(num.toString()).div(divider);
+  return number.toSignificantDigits(precision, 4).toString();
+}
+
+export function toBN(num: string, decimals: number): bigint {
+  if (num === "") return 0n;
+  const multiplier = new Decimal(10).toPower(decimals);
+  const number = new Decimal(num).mul(multiplier);
+  return BigInt(number.toFixed(0));
+}
+
+export function shortAddress(address?: string): string {
+  return address === undefined
+    ? ""
+    : `${address.slice(0, 6)}...${address.slice(address.length - 4)}`;
+}
+
+export function shortHash(address?: string): string {
+  return address === undefined ? "" : `${address.slice(0, 5)}...`;
+}
+
+export function formatPercentage(healthFactor: number, decimals = 2): string {
+  return (healthFactor / Number(PERCENTAGE_FACTOR)).toFixed(decimals);
+}
+
+export function formatLeverage(leverage: number, decimals = 2): string {
+  return (leverage / Number(LEVERAGE_DECIMALS)).toFixed(decimals);
+}

package/src/sdk/sdk-legacy/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./formatter";
+export * from "./math";
+export * from "./price";

package/src/sdk/sdk-legacy/utils/math.ts

@@ -0,0 +1,6 @@
+export class BigIntMath {
+  static abs = (x: bigint) => (x < 0n ? -x : x);
+  static max = (a: bigint, b: bigint) => (a > b ? a : b);
+  static min = (a: bigint, b: bigint) => (a < b ? a : b);
+  static neg = (a: bigint) => (a > 0 ? a * -1n : a);
+}

package/src/sdk/sdk-legacy/utils/price.ts

@@ -0,0 +1,27 @@
+import { PRICE_DECIMALS, WAD } from "../../constants";
+
+interface Target {
+  price: bigint;
+  decimals: number | undefined;
+}
+
+export class PriceUtils {
+  static calcTotalPrice = (
+    price: bigint,
+    amount: bigint,
+    decimals: number | undefined = 18,
+  ): bigint =>
+    (amount * WAD * price) / 10n ** BigInt(decimals) / PRICE_DECIMALS;
+
+  static convertByPrice(
+    totalMoney: bigint,
+    { price: targetPrice, decimals: targetDecimals = 18 }: Target,
+  ): bigint {
+    if (targetPrice <= 0n) return 0n;
+    return (
+      (totalMoney * 10n ** BigInt(targetDecimals) * PRICE_DECIMALS) /
+      targetPrice /
+      WAD
+    );
+  }
+}

package/src/sdk/types/index.ts

@@ -0,0 +1,5 @@
+export type * from "./logger";
+export type * from "./state";
+export type * from "./state-human";
+export type * from "./transactions";
+export type * from "./tvl";

package/src/sdk/types/logger.ts

@@ -0,0 +1,13 @@
+export interface LogFn {
+  <T extends object>(obj: T, msg?: string, ...args: any[]): void;
+  (obj: unknown, msg?: string, ...args: any[]): void;
+  (msg: string, ...args: any[]): void;
+}
+
+export interface ILogger {
+  debug: LogFn;
+  info: LogFn;
+  warn: LogFn;
+  error: LogFn;
+  child?: (bindings: Record<string, any>) => ILogger;
+}

package/src/sdk/types/state-human.ts

@@ -0,0 +1,224 @@
+import type { Address } from "viem";
+
+import type { TokenMetaData } from "../base";
+import type { PriceFeedContractType } from "../market";
+
+export interface BaseContractStateHuman {
+  address: string;
+  version: number;
+  contractType?: string;
+}
+
+export interface AddressProviderV3StateHuman extends BaseContractStateHuman {
+  addresses: Record<string, Record<number, string>>;
+}
+
+export interface GearStakingV3StateHuman extends BaseContractStateHuman {
+  successor: string;
+  migrator: string;
+}
+
+export type BotListStateHuman = BaseContractStateHuman;
+
+export interface CoreStateHuman {
+  addressProviderV3: AddressProviderV3StateHuman;
+  botList: BotListStateHuman;
+  gearStakingV3: GearStakingV3StateHuman;
+}
+
+export type PriceFeedStateHuman =
+  | BoundedOracleStateHuman
+  | AssetPriceFeedStateHuman
+  | RedstonePriceFeedStateHuman
+  | LPPriceFeedStateHuman
+  | BalancerWeightedPriceFeedStateHuman;
+
+export interface BasePriceFeedStateHuman extends BaseContractStateHuman {
+  description?: string;
+  stalenessPeriod: string;
+  skipCheck: boolean;
+  pricefeeds: PriceFeedStateHuman[];
+  trusted?: boolean;
+}
+
+export interface BoundedOracleStateHuman extends BasePriceFeedStateHuman {
+  contractType: "PRICE_FEED::BOUNDED";
+  upperBound: bigint;
+}
+
+export interface AssetPriceFeedStateHuman extends BasePriceFeedStateHuman {
+  contractType: PriceFeedContractType;
+}
+
+export interface LPPriceFeedStateHuman extends BasePriceFeedStateHuman {
+  contractType: PriceFeedContractType;
+  lpContract: Address;
+  lpToken: Address;
+  lowerBound: bigint;
+  upperBound: bigint;
+}
+
+export interface BalancerWeightedPriceFeedStateHuman
+  extends LPPriceFeedStateHuman {
+  contractType: "PRICE_FEED::BALANCER_WEIGHTED";
+  vault: Address;
+  poolId: Address;
+  weights: [bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint];
+}
+
+export interface RedstonePriceFeedStateHuman extends BasePriceFeedStateHuman {
+  contractType: "PRICE_FEED::REDSTONE";
+  dataId: string;
+  signers: Array<string>;
+  signersThreshold: number;
+}
+
+export interface PriceOracleV3StateHuman extends BaseContractStateHuman {
+  mainPriceFeeds: Record<string, PriceFeedStateHuman>;
+  reservePriceFeeds: Record<string, PriceFeedStateHuman>;
+}
+
+export interface CreditFacadeStateHuman extends BaseContractStateHuman {
+  expirable: boolean;
+  isDegenMode: boolean;
+  degenNFT: string;
+  expirationDate: number;
+  maxDebtPerBlockMultiplier: number;
+  botList: string;
+  minDebt: string;
+  maxDebt: string;
+  currentCumulativeLoss: string;
+  maxCumulativeLoss: string;
+  forbiddenTokenMask: string;
+  isPaused: boolean;
+}
+
+export interface CreditManagerStateHuman extends BaseContractStateHuman {
+  name: string;
+  accountFactory: string;
+  underlying: string;
+  pool: string;
+  creditFacade: string;
+  creditConfigurator: string;
+  maxEnabledTokens: number;
+  collateralTokens: Record<string, string>;
+  feeInterest: string;
+  feeLiquidation: string;
+  liquidationDiscount: string;
+  feeLiquidationExpired: string;
+  liquidationDiscountExpired: string;
+  quotedTokensMask: string;
+  contractsToAdapters: Record<string, string>;
+  creditAccounts: Array<Address>;
+}
+
+export type CreditConfiguratorStateHuman = BaseContractStateHuman;
+
+export interface CreditSuiteStateHuman {
+  creditFacade: CreditFacadeStateHuman;
+  creditManager: CreditManagerStateHuman;
+  creditConfigurator: CreditConfiguratorStateHuman;
+}
+
+export interface CreditManagerDebtParamsHuman {
+  borrowed: string;
+  limit: string;
+  availableToBorrow: string;
+}
+
+export interface PoolStateHuman extends BaseContractStateHuman {
+  underlying: string;
+  symbol: string;
+  name: string;
+  decimals: number;
+  availableLiquidity: string;
+  expectedLiquidity: string;
+  totalBorrowed: string;
+  totalDebtLimit: string;
+  creditManagerDebtParams: Record<string, CreditManagerDebtParamsHuman>;
+  totalSupply: string;
+  supplyRate: string;
+  baseInterestIndex: string;
+  baseInterestRate: string;
+  withdrawFee: string;
+  lastBaseInterestUpdate: string;
+  baseInterestIndexLU: string;
+  isPaused: boolean;
+}
+
+export interface QuotaParamsHuman {
+  rate: number;
+  quotaIncreaseFee: number;
+  totalQuoted: string;
+  limit: string;
+  isActive: boolean;
+}
+
+export interface PoolQuotaKeeperStateHuman extends BaseContractStateHuman {
+  quotas: Record<Address, QuotaParamsHuman>;
+}
+
+export interface GaugeParamsHuman {
+  minRate: string;
+  maxRate: string;
+  totalVotesLpSide: number;
+  totalVotesCaSide: number;
+  rate: string;
+}
+
+export interface GaugeStateHuman extends BaseContractStateHuman {
+  epochLastUpdate: number;
+  epochFrozen: boolean;
+  quotaParams: Record<Address, GaugeParamsHuman>;
+}
+
+export interface TumblerStateHuman extends BaseContractStateHuman {
+  epochLength: string;
+  rates: Record<string, string>;
+}
+
+export type RateKeeperStateHuman = GaugeStateHuman | TumblerStateHuman;
+
+export interface LinearInterestRateModelStateHuman
+  extends BaseContractStateHuman {
+  U1: string;
+  U2: string;
+  Rbase: string;
+  Rslope1: string;
+  Rslope2: string;
+  Rslope3: string;
+  isBorrowingMoreU2Forbidden: boolean;
+}
+
+export type InterestRateModelStateHuman = LinearInterestRateModelStateHuman;
+
+export interface PoolSuiteStateHuman {
+  pool: PoolStateHuman;
+  poolQuotaKeeper: PoolQuotaKeeperStateHuman;
+  interestRateModel?: InterestRateModelStateHuman;
+  rateKeeper: RateKeeperStateHuman;
+}
+
+export interface ZapperStateHuman extends BaseContractStateHuman {
+  tokenIn: string;
+  tokenOut: string;
+}
+
+export interface MarketStateHuman {
+  configurator: string;
+  pool: PoolSuiteStateHuman;
+  creditManagers: CreditSuiteStateHuman[];
+  priceOracle: PriceOracleV3StateHuman;
+  pausableAdmins: string[];
+  unpausableAdmins: string[];
+  emergencyLiquidators: string[];
+}
+
+export interface GearboxStateHuman {
+  block: number;
+  timestamp: number;
+  core: CoreStateHuman;
+  markets: MarketStateHuman[];
+  zappers: ZapperStateHuman[];
+  tokens: TokenMetaData[];
+}

package/src/sdk/types/state.ts

@@ -0,0 +1,8 @@
+import type { MarketData } from "../base";
+import type { AddressProviderState } from "../core";
+
+export interface GearboxState {
+  currentBlock: bigint;
+  addressProvider: AddressProviderState;
+  markets: MarketData[];
+}

package/src/sdk/types/transactions.ts

@@ -0,0 +1,22 @@
+import type { Address, Hex } from "viem";
+
+export interface ContractMethod {
+  inputs: any[];
+  name: string;
+  payable: boolean;
+}
+
+export interface RawTx {
+  to: Address;
+  value: string;
+  signature: string;
+  callData: Hex;
+  contractMethod: ContractMethod;
+  contractInputsValues: Record<string, any>;
+  description?: string;
+}
+
+export interface MultiCall {
+  target: Address;
+  callData: Hex;
+}

package/src/sdk/types/tvl.ts

@@ -0,0 +1,4 @@
+export interface TVL {
+  tvl: bigint;
+  tvlUSD: bigint;
+}