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

package/src/sdk/chain/Provider.ts

@@ -0,0 +1,99 @@
+import type { Chain, PublicClient, Transport } from "viem";
+import { createPublicClient, defineChain, fallback, http } from "viem";
+
+import { AddressLabeller } from "../base/AddressLabeller";
+import type { IAddressLabeller } from "../base/IAddressLabeller";
+import type { NetworkType } from "./chains";
+import { chains } from "./chains";
+
+export interface NetworkOptions {
+  /**
+   * Chain Id needs to be set, because we sometimemes use forked testnets with different chain ids
+   */
+  chainId: number;
+  /**
+   * NetworkType needs to be set, because we sometimemes use forked testnets with different chain ids
+   */
+  networkType: NetworkType;
+}
+
+export type TransportOptions =
+  | {
+      /**
+       * RPC URL (and fallbacks) to use.
+       */
+      rpcURLs: string[];
+    }
+  | {
+      /**
+       * Alternatively, can pass entire viem transport
+       */
+      transport: Transport;
+    };
+
+export interface ConnectionOptions {
+  /**
+   * RPC client timeout in milliseconds
+   */
+  timeout?: number;
+  /**
+   * Retry count for RPC
+   */
+  retryCount?: number;
+}
+
+export function createTransport(
+  opts: TransportOptions & ConnectionOptions,
+): Transport {
+  const { timeout = 120_000, retryCount } = opts;
+  if ("transport" in opts) {
+    return opts.transport;
+  }
+  const rpcs = opts.rpcURLs.map(url => http(url, { timeout, retryCount }));
+  return rpcs.length ? fallback(rpcs) : rpcs[0];
+}
+
+export class Provider {
+  public readonly chainId: number;
+  public readonly chain: Chain;
+  public readonly networkType: NetworkType;
+  public readonly addressLabels: IAddressLabeller;
+
+  #transport: Transport;
+  #publicClient: PublicClient;
+
+  constructor(opts: NetworkOptions & TransportOptions & ConnectionOptions) {
+    const { chainId, networkType } = opts;
+    this.chainId = chainId;
+    this.networkType = networkType;
+
+    // need to explicitly set chain id on testnets (e.g. 7878 = mainnet)
+    this.chain = defineChain({
+      ...chains[networkType],
+      id: chainId,
+    });
+    this.#transport = createTransport(opts);
+    this.#publicClient = createPublicClient({
+      chain: this.chain,
+      transport: this.#transport,
+    });
+
+    this.addressLabels = new AddressLabeller();
+  }
+
+  public get transport(): Transport {
+    return this.#transport;
+  }
+
+  public set transport(transport: Transport) {
+    this.#transport = transport;
+    this.#publicClient = createPublicClient({
+      chain: this.chain,
+      transport: this.#transport,
+    });
+  }
+
+  public get publicClient(): PublicClient {
+    return this.#publicClient;
+  }
+}

package/src/sdk/chain/chains.ts

@@ -0,0 +1,41 @@
+import type { Chain } from "viem";
+import { arbitrum, base, mainnet, optimism, sonic } from "viem/chains";
+
+export const SUPPORTED_CHAINS = [
+  "Mainnet",
+  "Arbitrum",
+  "Optimism",
+  "Base",
+  "Sonic",
+] as const;
+
+export type NetworkType = (typeof SUPPORTED_CHAINS)[number];
+
+export const chains: Record<NetworkType, Chain> = {
+  Mainnet: mainnet,
+  Arbitrum: arbitrum,
+  Optimism: optimism,
+  Base: base,
+  Sonic: sonic,
+};
+
+const CHAINS_BY_ID: Record<number, NetworkType> = {
+  [mainnet.id]: "Mainnet",
+  [arbitrum.id]: "Arbitrum",
+  [optimism.id]: "Optimism",
+  [base.id]: "Base",
+  [sonic.id]: "Sonic",
+};
+
+export const getNetworkType = (chainId: number): NetworkType => {
+  const chainType = CHAINS_BY_ID[chainId];
+  if (chainType) {
+    return chainType;
+  }
+
+  throw new Error("Unsupported network");
+};
+
+export const isSupportedNetwork = (
+  chainId: number | undefined,
+): chainId is number => chainId !== undefined && !!CHAINS_BY_ID[chainId];

package/src/sdk/chain/detectChain.ts

@@ -0,0 +1,21 @@
+import type { Chain, Transport } from "viem";
+import { createPublicClient, defineChain, http } from "viem";
+
+import { detectNetwork } from "../utils/viem";
+import { chains } from "./chains";
+
+export async function detectChain(
+  transportOrRPC: Transport | string,
+): Promise<Chain> {
+  const transport =
+    typeof transportOrRPC === "string" ? http(transportOrRPC) : transportOrRPC;
+  const tempClient = createPublicClient({ transport });
+  const [networkType, chainId] = await Promise.all([
+    detectNetwork(tempClient),
+    tempClient.getChainId(),
+  ]);
+  return defineChain({
+    ...chains[networkType],
+    id: chainId,
+  });
+}

package/src/sdk/chain/index.ts

@@ -0,0 +1,3 @@
+export * from "./chains";
+export * from "./detectChain";
+export * from "./Provider";

package/src/sdk/constants/address-provider.ts

@@ -0,0 +1,47 @@
+import type { Address } from "viem";
+
+import type { NetworkType } from "../chain";
+import { NOT_DEPLOYED } from "./addresses";
+
+export const NO_VERSION = 0;
+
+export const AP_ACCOUNT_FACTORY = "ACCOUNT_FACTORY";
+export const AP_ACL = "ACL";
+export const AP_ADAPTER_COMPRESSOR = "ADAPTER_COMPRESSOR";
+export const AP_BOT_LIST = "BOT_LIST";
+export const AP_CONTRACTS_REGISTER = "CONTRACTS_REGISTER";
+export const AP_CONTROLLER_TIMELOCK = "CONTROLLER_TIMELOCK";
+export const AP_CREDIT_ACCOUNT_COMPRESSOR = "CREDIT_ACCOUNT_COMPRESSOR";
+export const AP_CREDIT_SUITE_COMPRESSOR = "CREDIT_SUITE_COMPRESSOR";
+export const AP_DATA_COMPRESSOR = "DATA_COMPRESSOR";
+export const AP_DELEVERAGE_BOT_HV = "DELEVERAGE_BOT_HV";
+export const AP_DELEVERAGE_BOT_LV = "DELEVERAGE_BOT_LV";
+export const AP_DELEVERAGE_BOT_PEGGED = "DELEVERAGE_BOT_PEGGED";
+export const AP_GAUGE_COMPRESSOR = "GAUGE_COMPRESSOR";
+export const AP_GEAR_STAKING = "GEAR_STAKING";
+export const AP_GEAR_TOKEN = "GEAR_TOKEN";
+export const AP_INFLATION_ATTACK_BLOCKER = "INFLATION_ATTACK_BLOCKER";
+export const AP_INSOLVENCY_CHECKER = "INSOLVENCY_CHECKER";
+export const AP_MARKET_COMPRESSOR = "MARKET_COMPRESSOR";
+export const AP_MARKET_CONFIGURATOR = "MARKET_CONFIGURATOR";
+export const AP_PARTIAL_LIQUIDATION_BOT = "PARTIAL_LIQUIDATION_BOT";
+export const AP_PERIPHERY_COMPRESSOR = "PERIPHERY_COMPRESSOR";
+export const AP_POOL_COMPRESSOR = "POOL_COMPRESSOR";
+export const AP_PRICE_FEED_COMPRESSOR = "PRICE_FEED_COMPRESSOR";
+export const AP_PRICE_ORACLE = "PRICE_ORACLE";
+export const AP_REWARDS_COMPRESSOR = "REWARDS_COMPRESSOR";
+export const AP_ROUTER = "LOCAL::ROUTER";
+export const AP_TOKEN_COMPRESSOR = "TOKEN_COMPRESSOR";
+export const AP_TREASURY = "TREASURY";
+export const AP_WETH_GATEWAY = "WETH_GATEWAY";
+export const AP_WETH_TOKEN = "WETH_TOKEN";
+export const AP_ZAPPER_REGISTER = "ZAPPER_REGISTER";
+export const AP_ZERO_PRICE_FEED = "ZERO_PRICE_FEED";
+
+export const ADDRESS_PROVIDER: Record<NetworkType, Address> = {
+  Mainnet: "0x9ea7b04Da02a5373317D745c1571c84aaD03321D",
+  Arbitrum: "0x7d04eCdb892Ae074f03B5D0aBA03796F90F3F2af",
+  Optimism: "0x3761ca4BFAcFCFFc1B8034e69F19116dD6756726",
+  Base: NOT_DEPLOYED,
+  Sonic: "0x4b27b296273B72d7c7bfee1ACE93DC081467C41B",
+};

package/src/sdk/constants/addresses.ts

@@ -0,0 +1,82 @@
+import type { Address } from "viem";
+
+import type { NetworkType } from "../chain";
+
+export const MULTICALL_ADDRESS: Address =
+  "0xcA11bde05977b3631167028862bE2a173976CA11";
+
+/**
+ * Address 0x0000000000000000000000000000000000000000
+ */
+export const ADDRESS_0X0: Address =
+  "0x0000000000000000000000000000000000000000";
+
+/**
+ * Dummy address to satisfy `0x${string}` typecheck, but fail on `isAddress` check
+ */
+export const NOT_DEPLOYED = "0xNOT DEPLOYED";
+
+/**
+ * Well-known USDC token address used to determine NetworkType on testnets with different chain ids
+ */
+export const USDC: Record<NetworkType, Address> = {
+  Mainnet: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  Arbitrum: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  Optimism: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  Base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  Sonic: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894",
+};
+
+export const USDT: Record<NetworkType, Address> = {
+  Mainnet: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+  Arbitrum: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+  Optimism: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58",
+  Base: NOT_DEPLOYED,
+  Sonic: NOT_DEPLOYED,
+};
+
+export const WETH: Record<NetworkType, Address> = {
+  Mainnet: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+  Arbitrum: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+  Optimism: "0x4200000000000000000000000000000000000006",
+  Base: NOT_DEPLOYED,
+  Sonic: NOT_DEPLOYED,
+};
+
+export const TIMELOCK: Record<NetworkType, Address> = {
+  Mainnet: "0xa133C9A92Fb8dDB962Af1cbae58b2723A0bdf23b",
+  Arbitrum: "0x148DD932eCe1155c11006F5650c6Ff428f8D374A",
+  Optimism: "0x148DD932eCe1155c11006F5650c6Ff428f8D374A",
+  Base: NOT_DEPLOYED,
+  Sonic: "0xAdbF876ce58CB65c99b18078353e1DCB16E69e84",
+};
+
+export const GEARBOX_MULTISIG: Record<NetworkType, Address> = {
+  Mainnet: "0xA7D5DDc1b8557914F158076b228AA91eF613f1D5",
+  Arbitrum: "0x57Fd8B1a9213624157786Fff4a7bc532Ce717773",
+  Optimism: "0x8bA8cd6D00919ceCc19D9B4A2c8669a524883C4c",
+  Base: NOT_DEPLOYED,
+  Sonic: "0xacEB9dc6a81f1C9E2d8a86c3bFec3f6EF584139D",
+};
+
+export const GEARBOX_RISK_CURATORS: Record<NetworkType, Address[]> = {
+  Mainnet: [TIMELOCK.Mainnet],
+  Arbitrum: [TIMELOCK.Arbitrum],
+  Optimism: [TIMELOCK.Optimism],
+  Base: [TIMELOCK.Base],
+  Sonic: [TIMELOCK.Sonic],
+};
+
+/**
+ * Depreciated pools
+ */
+export const DEPRECIATED_POOLS: Record<NetworkType, Record<Address, string>> = {
+  Mainnet: {
+    ["0x1dc0f3359a254f876b37906cfc1000a35ce2d717".toLowerCase() as Address]:
+      "USDT_V3_BROKEN",
+  },
+  Arbitrum: {},
+  Optimism: {},
+  Base: {},
+  Sonic: {},
+};

package/src/sdk/constants/bot-permissions.ts

@@ -0,0 +1,36 @@
+export enum BotPermissions {
+  ADD_COLLATERAL = 1,
+  INCREASE_DEBT = 1 << 1,
+  DECREASE_DEBT = 1 << 2,
+  ENABLE_TOKEN = 1 << 3,
+  DISABLE_TOKEN = 1 << 4,
+  WITHDRAW_COLLATERAL = 1 << 5,
+  UPDATE_QUOTA = 1 << 6,
+  REVOKE_ALLOWANCES = 1 << 7,
+
+  EXTERNAL_CALLS = 1 << 16,
+
+  ALL_CREDIT_FACADE_CALLS = ADD_COLLATERAL |
+    WITHDRAW_COLLATERAL |
+    INCREASE_DEBT |
+    DECREASE_DEBT |
+    ENABLE_TOKEN |
+    DISABLE_TOKEN |
+    UPDATE_QUOTA |
+    REVOKE_ALLOWANCES,
+
+  ALLS = ALL_CREDIT_FACADE_CALLS | EXTERNAL_CALLS,
+}
+
+export function botPermissionsToString(value: bigint): string {
+  let result = "";
+  for (let i = 0; i < 16; i++) {
+    if ((value & (1n << BigInt(i))) !== 0n) {
+      if (result.length > 0) {
+        result += " | ";
+      }
+      result += BotPermissions[1 << i];
+    }
+  }
+  return result;
+}

package/src/sdk/constants/index.ts

@@ -0,0 +1,6 @@
+export * from "./address-provider";
+export * from "./addresses";
+export * from "./bot-permissions";
+export * from "./math";
+export * from "./networks";
+export * from "./periphery";

package/src/sdk/constants/math.ts

@@ -0,0 +1,23 @@
+export const MAX_INT = BigInt(
+  "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+);
+export const MIN_INT96 = -39614081257132168796771975168n;
+export const MAX_UINT256 =
+  115792089237316195423570985008687907853269984665640564039457584007913129639935n;
+export const MAX_UINT16 = 65535n;
+
+export const RAY_DECIMALS_POW = 27;
+export const RAY = 10n ** BigInt(RAY_DECIMALS_POW);
+export const halfRAY = RAY / 2n;
+export const WAD_DECIMALS_POW = 18;
+export const WAD = 10n ** BigInt(WAD_DECIMALS_POW);
+
+export const PRICE_DECIMALS_POW = 8;
+export const PRICE_DECIMALS = 10n ** BigInt(PRICE_DECIMALS_POW);
+
+export const SECONDS_PER_YEAR = 365 * 24 * 3600;
+
+export const PERCENTAGE_DECIMALS = 100n;
+export const PERCENTAGE_FACTOR = 10000n;
+export const LEVERAGE_DECIMALS = 100n;
+export const SLIPPAGE_DECIMALS = 100n;

package/src/sdk/constants/networks.ts

@@ -0,0 +1,38 @@
+import type { NetworkType } from "../chain";
+
+/**
+ * Block number when address provider was deployed
+ */
+export const ADDRESS_PROVIDER_BLOCK: Record<NetworkType, bigint> = {
+  Mainnet: 18433056n, // AddressProvderV3 0x9ea7b04Da02a5373317D745c1571c84aaD03321D
+  Arbitrum: 184650310n,
+  Optimism: 118410666n,
+  Base: 0n,
+  Sonic: 9779380n,
+};
+
+const BLOCK_DURATION_BY_NETWORK: Record<NetworkType, number> = {
+  Mainnet: 12.05,
+  Arbitrum: 0.26,
+  Optimism: 2,
+  Base: 2.01,
+  Sonic: 0.91,
+};
+
+const RAMP_TIME = 30 * 24 * 60 * 60 * 1.2;
+export const RAMP_DURATION_BY_NETWORK: Record<NetworkType, bigint> = {
+  Mainnet: BigInt(Math.floor(RAMP_TIME / BLOCK_DURATION_BY_NETWORK.Mainnet)),
+  Arbitrum: BigInt(Math.floor(RAMP_TIME / BLOCK_DURATION_BY_NETWORK.Arbitrum)),
+  Optimism: BigInt(Math.floor(RAMP_TIME / BLOCK_DURATION_BY_NETWORK.Optimism)),
+  Base: BigInt(Math.floor(RAMP_TIME / BLOCK_DURATION_BY_NETWORK.Base)),
+  Sonic: BigInt(Math.floor(RAMP_TIME / BLOCK_DURATION_BY_NETWORK.Sonic)),
+};
+
+const WEEK = 7 * 24 * 60 * 60;
+export const BLOCKS_PER_WEEK_BY_NETWORK: Record<NetworkType, bigint> = {
+  Mainnet: BigInt(Math.floor(WEEK / BLOCK_DURATION_BY_NETWORK.Mainnet)),
+  Arbitrum: BigInt(Math.floor(WEEK / BLOCK_DURATION_BY_NETWORK.Arbitrum)),
+  Optimism: BigInt(Math.floor(WEEK / BLOCK_DURATION_BY_NETWORK.Optimism)),
+  Base: BigInt(Math.floor(WEEK / BLOCK_DURATION_BY_NETWORK.Base)),
+  Sonic: BigInt(Math.floor(WEEK / BLOCK_DURATION_BY_NETWORK.Sonic)),
+};

package/src/sdk/constants/periphery.ts

@@ -0,0 +1,7 @@
+export const PERIPHERY_CONTRACTS = [
+  "DEGEN_DISTRIBUTOR",
+  "DEGEN_NFT",
+  "MULTI_PAUSE",
+] as const;
+
+export type PeripheryContract = (typeof PERIPHERY_CONTRACTS)[number];

package/src/sdk/core/BotListV3Contract.ts

@@ -0,0 +1,103 @@
+import type {
+  Address,
+  ContractEventName,
+  DecodeFunctionDataReturnType,
+  Log,
+} from "viem";
+
+import { iBotListV300Abi } from "../../abi/v300";
+import { BaseContract } from "../base";
+import { ADDRESS_PROVIDER_BLOCK, botPermissionsToString } from "../constants";
+import type { GearboxSDK } from "../GearboxSDK";
+import type { BotListStateHuman } from "../types";
+
+const abi = iBotListV300Abi;
+type abi = typeof abi;
+
+export class BotListContract extends BaseContract<abi> {
+  #approvedCreditManagers?: Set<Address>;
+  #currentBlock: bigint;
+
+  constructor(sdk: GearboxSDK, address: Address) {
+    super(sdk, { addr: address, name: "BotListV3", abi });
+    this.#currentBlock = ADDRESS_PROVIDER_BLOCK[sdk.provider.networkType];
+  }
+
+  public parseFunctionParams(
+    params: DecodeFunctionDataReturnType<abi>,
+  ): Array<string> | undefined {
+    switch (params.functionName) {
+      case "setCreditManagerApprovedStatus": {
+        const [creditManager, status] = params.args;
+        return [this.addressLabels.get(creditManager), `${status}`];
+      }
+      case "setBotSpecialPermissions": {
+        const [bot, creditManager, permissions] = params.args;
+        return [
+          this.addressLabels.get(bot),
+          this.addressLabels.get(creditManager),
+          botPermissionsToString(permissions),
+        ];
+      }
+      default:
+        return undefined;
+    }
+  }
+
+  public async syncState(toBlock: bigint): Promise<void> {
+    const logs = await this.provider.publicClient.getContractEvents({
+      address: this.address,
+      abi: this.abi,
+      fromBlock: this.#currentBlock,
+      toBlock,
+    });
+    logs.forEach(e => this.processLog(e));
+    this.#currentBlock = toBlock;
+  }
+
+  public override processLog(
+    log: Log<
+      bigint,
+      number,
+      false,
+      undefined,
+      undefined,
+      abi,
+      ContractEventName<abi>
+    >,
+  ): void {
+    switch (log.eventName) {
+      case "SetCreditManagerApprovedStatus":
+        if (log.args.approved) {
+          this.approvedCreditManagers.add(log.args.creditManager!);
+        } else {
+          this.approvedCreditManagers.delete(log.args.creditManager!);
+        }
+        break;
+
+      case "SetBotSpecialPermissions":
+        this.logger?.debug(
+          `Bot ${log.args.bot} has been given permissions ${botPermissionsToString(
+            log.args.permissions!,
+          )} for credit manager ${log.args.creditManager}`,
+        );
+        break;
+      default:
+        this.logger?.warn(`Unknown event: ${log.eventName}`);
+        break;
+    }
+  }
+
+  public get approvedCreditManagers(): Set<Address> {
+    if (!this.#approvedCreditManagers) {
+      throw new Error(
+        "BotListContract state needs to be synced to load approvedCreditManagers",
+      );
+    }
+    return this.#approvedCreditManagers;
+  }
+
+  public override stateHuman(raw = true): BotListStateHuman {
+    return super.stateHuman(raw);
+  }
+}

package/src/sdk/core/GearStakingV3Contract.ts

@@ -0,0 +1,84 @@
+import type { Address, DecodeFunctionDataReturnType } from "viem";
+
+import { iGearStakingV300Abi } from "../../abi/v300";
+import type { PermitResult } from "../accounts";
+import { BaseContract, VotingContractStatus } from "../base";
+import { ADDRESS_0X0 } from "../constants";
+import type { GearboxSDK } from "../GearboxSDK";
+import type { GearStakingV3StateHuman, RawTx } from "../types";
+
+const abi = iGearStakingV300Abi;
+type abi = typeof abi;
+
+export interface MultiVote {
+  votingContract: Address;
+  voteAmount: bigint;
+  isIncrease: boolean;
+  extraData: Address;
+}
+
+export class GearStakingContract extends BaseContract<abi> {
+  constructor(sdk: GearboxSDK, address: Address) {
+    super(sdk, { addr: address, name: "GearStakingV3", abi });
+  }
+
+  parseFunctionParams(
+    params: DecodeFunctionDataReturnType<abi>,
+  ): Array<string> | undefined {
+    switch (params.functionName) {
+      case "setVotingContractStatus": {
+        const [address, status] = params.args;
+        return [this.addressLabels.get(address), VotingContractStatus[status]];
+      }
+      default:
+        return undefined;
+    }
+  }
+
+  public override stateHuman(raw = true): GearStakingV3StateHuman {
+    return {
+      ...super.stateHuman(raw),
+      successor: this.labelAddress(ADDRESS_0X0),
+      migrator: this.labelAddress(ADDRESS_0X0),
+    };
+  }
+
+  public deposit(amount: bigint, votes: Array<MultiVote>): RawTx {
+    return this.createRawTx({
+      functionName: "deposit",
+      args: [amount, votes],
+    });
+  }
+
+  public depositWithPermit(
+    amount: bigint,
+    votes: Array<MultiVote>,
+    permit: PermitResult,
+  ): RawTx {
+    return this.createRawTx({
+      functionName: "depositWithPermit",
+      args: [amount, votes, permit.deadline, permit.v, permit.r, permit.s],
+    });
+  }
+
+  public withdraw(amount: bigint, to: Address, votes: Array<MultiVote>): RawTx {
+    return this.createRawTx({
+      functionName: "withdraw",
+      args: [amount, to, votes],
+    });
+  }
+
+  public claimWithdrawals(to: Address): RawTx {
+    return this.createRawTx({
+      functionName: "claimWithdrawals",
+      args: [to],
+    });
+  }
+
+  public multivote(votes: Array<MultiVote>): RawTx {
+    return this.createRawTx({
+      functionName: "multivote",
+      args: [votes],
+    });
+  }
+}