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

package/src/sdk/sdk-gov-legacy/tokens/tokenData.ts

@@ -0,0 +1,44 @@
+import type { Address } from "viem";
+
+import type { NetworkType } from "../../chain";
+import { NOT_DEPLOYED } from "../../constants";
+import type { SupportedToken } from "./token";
+import { tokenDataByNetwork } from "./token";
+
+export const connectors: Record<NetworkType, Array<SupportedToken>> = {
+  Mainnet: [
+    "WETH",
+    "DAI",
+    "USDC",
+    "USDe",
+    "FRAX",
+    "rETH",
+    "ezETH",
+    "GHO",
+    "weETH",
+    "wstETH",
+    "STETH",
+    "WBTC",
+    "USDS",
+    "eBTC",
+    "LBTC",
+    "solvBTC",
+    "pumpBTC",
+  ],
+  Arbitrum: ["WETH", "DAI", "USDC", "USDT", "rETH", "USDC_e", "wstETH"],
+  Optimism: ["WETH", "USDC", "USDT", "USDC_e", "wstETH"],
+  Base: ["WETH", "USDC", "USDT"],
+  Sonic: ["wS"],
+};
+
+export function getConnectors(networkType: NetworkType): Address[] {
+  return connectors[networkType].map(e => {
+    const result = tokenDataByNetwork[networkType][e];
+
+    if (!result || result === NOT_DEPLOYED) {
+      throw new Error(`connector token ${e} not found`);
+    }
+
+    return result.toLowerCase() as Address;
+  });
+}

package/src/sdk/sdk-gov-legacy/tokens/tokenType.ts

@@ -0,0 +1,33 @@
+import type { NetworkType } from "../../chain";
+
+export enum TokenType {
+  NO_TOKEN,
+  NORMAL_TOKEN,
+  CURVE_LP_TOKEN,
+  YEARN_ON_NORMAL_TOKEN,
+  YEARN_ON_CURVE_TOKEN,
+  CONVEX_LP_TOKEN,
+  CONVEX_STAKED_TOKEN,
+  DIESEL_LP_TOKEN,
+  GEAR_TOKEN,
+  COMPOUND_V2_C_TOKEN,
+  BALANCER_LP_TOKEN,
+  AAVE_V2_A_TOKEN,
+  WRAPPED_AAVE_V2_TOKEN,
+  ERC4626_VAULT_TOKEN,
+  WRAPPED_TOKEN,
+  AURA_LP_TOKEN,
+  AURA_STAKED_TOKEN,
+  CONVEX_L2_STAKED_TOKEN,
+  ZIRCUIT_STAKED_TOKEN,
+  STAKING_REWARDS_PHANTOM_TOKEN,
+}
+
+export enum PhantomTokenType {
+  NO_TOKEN,
+  CONVEX_PHANTOM_TOKEN,
+  ZIRCUIT_PHANTOM_TOKEN,
+  STAKING_REWARDS_PHANTOM_TOKEN,
+}
+
+export type TokenNetwork = NetworkType | "AllNetworks";

package/src/sdk/sdk-gov-legacy/tokens/wrapped.ts

@@ -0,0 +1,28 @@
+import type { TokenBase } from "./token";
+import type { TokenNetwork } from "./tokenType";
+import { TokenType } from "./tokenType";
+
+export type WrappedToken = "sfrxETH";
+
+export type WrappedTokenData = {
+  symbol: WrappedToken;
+  type: Partial<
+    Record<TokenNetwork, TokenType.WRAPPED_TOKEN | TokenType.NORMAL_TOKEN>
+  >;
+} & TokenBase;
+
+export const wrappedTokens: Record<WrappedToken, WrappedTokenData> = {
+  sfrxETH: {
+    name: "sfrxETH",
+
+    symbol: "sfrxETH",
+    type: {
+      Mainnet: TokenType.WRAPPED_TOKEN,
+      Arbitrum: TokenType.NORMAL_TOKEN,
+      Optimism: TokenType.NORMAL_TOKEN,
+    },
+  },
+};
+
+export const isWrappedToken = (t: unknown): t is WrappedToken =>
+  typeof t === "string" && !!wrappedTokens[t as WrappedToken];

package/src/sdk/sdk-gov-legacy/tokens/yearn.ts

@@ -0,0 +1,122 @@
+import type { YearnVaultContract } from "../contracts";
+import type { CurveLPToken } from "./curveLP";
+import type { NormalToken } from "./normal";
+import type { TokenBase } from "./token";
+import type { TokenNetwork } from "./tokenType";
+import { TokenType } from "./tokenType";
+
+export type YearnLPToken =
+  | "yvDAI"
+  | "yvUSDC"
+  | "yvUSDC_e"
+  | "yvWETH"
+  | "yvWBTC"
+  | "yvUSDT"
+  | "yvOP"
+  | "yvCurve_stETH"
+  | "yvCurve_FRAX";
+
+export type YearnVaultTokenData = {
+  symbol: YearnLPToken;
+  type: Partial<Record<TokenNetwork, TokenType.YEARN_ON_NORMAL_TOKEN>>;
+  underlying: NormalToken;
+  vault: YearnVaultContract;
+} & TokenBase;
+
+export type YearnVaultOfCurveLPTokenData = {
+  symbol: YearnLPToken;
+  type: Partial<Record<TokenNetwork, TokenType.YEARN_ON_CURVE_TOKEN>>;
+  underlying: CurveLPToken;
+  vault: YearnVaultContract;
+} & TokenBase;
+
+export type YearnVaultOfMetaCurveLPTokenData = {
+  symbol: YearnLPToken;
+  type: Partial<Record<TokenNetwork, TokenType.YEARN_ON_CURVE_TOKEN>>;
+  underlying: CurveLPToken;
+  vault: YearnVaultContract;
+} & TokenBase;
+
+export const yearnTokens: Record<
+  YearnLPToken,
+  | YearnVaultTokenData
+  | YearnVaultOfCurveLPTokenData
+  | YearnVaultOfMetaCurveLPTokenData
+> = {
+  // YEARN TOKENS
+  yvDAI: {
+    name: "Yearn yvDAI",
+    symbol: "yvDAI",
+    type: { AllNetworks: TokenType.YEARN_ON_NORMAL_TOKEN },
+    underlying: "DAI",
+    vault: "YEARN_DAI_VAULT",
+  },
+
+  yvUSDC: {
+    name: "Yearn yvUSDC",
+    symbol: "yvUSDC",
+    type: { AllNetworks: TokenType.YEARN_ON_NORMAL_TOKEN },
+    underlying: "USDC",
+    vault: "YEARN_USDC_VAULT",
+  },
+
+  yvUSDC_e: {
+    name: "Yearn yvUSDC.e",
+    symbol: "yvUSDC_e",
+    type: { AllNetworks: TokenType.YEARN_ON_NORMAL_TOKEN },
+    underlying: "USDC_e",
+    vault: "YEARN_USDC_E_VAULT",
+  },
+
+  yvWETH: {
+    name: "Yearn yvWETH",
+    symbol: "yvWETH",
+    type: { AllNetworks: TokenType.YEARN_ON_NORMAL_TOKEN },
+    underlying: "WETH",
+    vault: "YEARN_WETH_VAULT",
+  },
+
+  yvWBTC: {
+    name: "Yearn yvWBTC",
+    symbol: "yvWBTC",
+    type: { AllNetworks: TokenType.YEARN_ON_NORMAL_TOKEN },
+    underlying: "WBTC",
+    vault: "YEARN_WBTC_VAULT",
+  },
+
+  yvUSDT: {
+    name: "Yearn yvUSDT",
+    symbol: "yvUSDT",
+    type: { AllNetworks: TokenType.YEARN_ON_NORMAL_TOKEN },
+    underlying: "USDT",
+    vault: "YEARN_USDT_VAULT",
+  },
+
+  yvOP: {
+    name: "Yearn yvOP",
+    symbol: "yvOP",
+    type: { AllNetworks: TokenType.YEARN_ON_NORMAL_TOKEN },
+    underlying: "OP",
+    vault: "YEARN_OP_VAULT",
+  },
+
+  // YEARN- CURVE TOKENS
+  yvCurve_stETH: {
+    name: "Yearn yvCurve-stETH",
+    symbol: "yvCurve_stETH",
+    type: { AllNetworks: TokenType.YEARN_ON_CURVE_TOKEN },
+    underlying: "steCRV",
+    vault: "YEARN_CURVE_STETH_VAULT",
+  },
+
+  yvCurve_FRAX: {
+    name: "Yearn yvCurve-FRAX",
+    symbol: "yvCurve_FRAX",
+    type: { AllNetworks: TokenType.YEARN_ON_CURVE_TOKEN },
+    underlying: "FRAX3CRV",
+    vault: "YEARN_CURVE_FRAX_VAULT",
+  },
+};
+
+export const isYearnLPToken = (t: unknown): t is YearnLPToken =>
+  typeof t === "string" && !!yearnTokens[t as YearnLPToken];

package/src/sdk/sdk-gov-legacy/tokens/zircuit.ts

@@ -0,0 +1,44 @@
+import type { SupportedToken, TokenBase } from "./token";
+import type { TokenNetwork } from "./tokenType";
+import { TokenType } from "./tokenType";
+
+export type ZircuitStakedPhantomToken = "zpufETH";
+
+export type ZircuitPhantomTokenData = {
+  symbol: ZircuitStakedPhantomToken;
+  type: Partial<Record<TokenNetwork, TokenType.ZIRCUIT_STAKED_TOKEN>>;
+  underlying: SupportedToken;
+} & TokenBase;
+
+export const zircuitStakedPhantomTokens: Record<
+  ZircuitStakedPhantomToken,
+  ZircuitPhantomTokenData
+> = {
+  zpufETH: {
+    name: "Zircuit staked pufETH",
+    symbol: "zpufETH",
+    type: {
+      AllNetworks: TokenType.ZIRCUIT_STAKED_TOKEN,
+    },
+    underlying: "pufETH",
+  },
+};
+
+export const zircuitTokens: Record<
+  ZircuitStakedPhantomToken,
+  ZircuitPhantomTokenData
+> = {
+  ...zircuitStakedPhantomTokens,
+};
+
+export const isZircuitStakedPhantomToken = (
+  t: unknown,
+): t is ZircuitStakedPhantomToken =>
+  typeof t === "string" && !!zircuitTokens[t as ZircuitStakedPhantomToken];
+
+export const zircuitStakedTokenByToken = Object.values(
+  zircuitStakedPhantomTokens,
+).reduce<Partial<Record<SupportedToken, SupportedToken>>>((acc, value) => {
+  acc[value.underlying] = value.symbol;
+  return acc;
+}, {});

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

@@ -0,0 +1,149 @@
+import type { Address } from "viem";
+
+import type { LPTokens, SupportedToken } from "../../sdk-gov-legacy";
+import { isLPToken } from "../../sdk-gov-legacy";
+import type { PartialRecord } from "../../utils";
+
+// all extra tokens
+type ExtraFarmTokens = Extract<
+  SupportedToken,
+  | "STETH"
+  | "rETH"
+  | "osETH"
+  | "cbETH"
+  | "wstETH"
+  | "weETH"
+  | "ezETH"
+  | "sfrxETH"
+  | "USDe"
+  | "rsETH"
+  | "rswETH"
+  | "pufETH"
+  | "pzETH"
+  | "rstETH"
+  | "steakLRT"
+  | "amphrETH"
+  | "LBTC"
+  | "Re7LRT"
+  | "PT_ezETH_26DEC2024"
+  | "PT_eETH_26DEC2024"
+  | "PT_sUSDe_26DEC2024"
+  | "PT_eBTC_26DEC2024"
+  | "PT_LBTC_27MAR2025"
+  | "eBTC"
+  | "PT_cornLBTC_26DEC2024"
+  | "PT_corn_eBTC_27MAR2025"
+  | "PT_corn_pumpBTC_26DEC2024"
+  | "pumpBTC"
+  | "PT_sUSDe_27MAR2025"
+  | "DVstETH"
+  | "beraSTONE"
+  | "PT_sUSDe_29MAY2025"
+  | "tETH"
+  | "PT_beraSTONE_10APR2025"
+  | "stS"
+  | "csUSDL"
+  | "scUSD"
+>;
+
+// tokens with apy among them
+type ExtraTokensWithAPY = Extract<
+  ExtraFarmTokens,
+  | "STETH"
+  | "rETH"
+  | "osETH"
+  | "cbETH"
+  | "wstETH"
+  | "sfrxETH"
+  | "pzETH"
+  | "ezETH"
+  | "Re7LRT"
+  | "rsETH"
+  | "weETH"
+  | "rswETH"
+  | "rstETH"
+  | "steakLRT"
+  | "amphrETH"
+  | "pufETH"
+  | "PT_ezETH_26DEC2024"
+  | "PT_eETH_26DEC2024"
+  | "PT_sUSDe_26DEC2024"
+  | "PT_eBTC_26DEC2024"
+  | "PT_LBTC_27MAR2025"
+  | "PT_cornLBTC_26DEC2024"
+  | "PT_corn_eBTC_27MAR2025"
+  | "PT_corn_pumpBTC_26DEC2024"
+  | "PT_sUSDe_27MAR2025"
+  | "DVstETH"
+  | "PT_sUSDe_29MAY2025"
+  | "tETH"
+  | "PT_beraSTONE_10APR2025"
+  | "stS"
+  | "csUSDL"
+  | "scUSD"
+>;
+
+// LRT & LST tokens among them
+type LRTAndLSTTokens = Exclude<ExtraFarmTokens, "USDe">;
+
+const EXTRA_FARM_TOKENS: Record<ExtraFarmTokens, true> = {
+  STETH: true,
+  rETH: true,
+  osETH: true,
+  cbETH: true,
+  wstETH: true,
+  weETH: true,
+  ezETH: true,
+  sfrxETH: true,
+  USDe: true,
+  rsETH: true,
+  rswETH: true,
+  pufETH: true,
+  pzETH: true,
+  rstETH: true,
+  steakLRT: true,
+  amphrETH: true,
+  LBTC: true,
+  Re7LRT: true,
+  PT_ezETH_26DEC2024: true,
+  PT_eETH_26DEC2024: true,
+  PT_sUSDe_26DEC2024: true,
+  PT_eBTC_26DEC2024: true,
+  PT_LBTC_27MAR2025: true,
+  eBTC: true,
+  PT_cornLBTC_26DEC2024: true,
+  PT_corn_eBTC_27MAR2025: true,
+  PT_corn_pumpBTC_26DEC2024: true,
+  pumpBTC: true,
+  PT_sUSDe_27MAR2025: true,
+  DVstETH: true,
+  beraSTONE: true,
+  PT_sUSDe_29MAY2025: true,
+  tETH: true,
+  PT_beraSTONE_10APR2025: true,
+  stS: true,
+  csUSDL: true,
+  scUSD: true,
+};
+
+export const isExtraFarmToken = (t: unknown): t is ExtraFarmTokens => {
+  if (typeof t !== "string") return false;
+  return !!EXTRA_FARM_TOKENS[t as ExtraFarmTokens];
+};
+
+const { USDe, ...rest } = EXTRA_FARM_TOKENS;
+const LRT_LST: Record<LRTAndLSTTokens, true> = rest;
+
+export const isLRT_LSTToken = (t: unknown): t is LRTAndLSTTokens => {
+  if (typeof t !== "string") return false;
+  return !!LRT_LST[t as LRTAndLSTTokens];
+};
+
+export type TokensWithAPY = LPTokens | ExtraTokensWithAPY;
+export type TokensAPYList = PartialRecord<Address, number>;
+
+export type AllLPTokens = LPTokens | ExtraFarmTokens;
+
+export const isFarmToken = (t: unknown): t is AllLPTokens => {
+  return isLPToken(t) || isExtraFarmToken(t);
+};

package/src/sdk/sdk-legacy/core/assets.ts

@@ -0,0 +1,200 @@
+import type { Address } from "viem";
+
+import type { Asset } from "../../router";
+import type { TokenData } from "../tokens/tokenData";
+import { BigIntMath } from "../utils/math";
+import { PriceUtils } from "../utils/price";
+import { CreditAccountData_Legacy } from "./creditAccount";
+
+export interface AssetWithView extends Asset {
+  balanceView: string;
+}
+
+export interface AssetWithAmountInTarget extends Asset {
+  amountInTarget: bigint;
+}
+
+interface NextAssetProps<T extends Asset> {
+  allowedTokens: Array<Address>;
+  selectedAssets: Array<T>;
+  balances: Record<Address, bigint>;
+  tokensList: Record<Address, TokenData>;
+  prices?: Record<Address, bigint>;
+}
+
+export type WrapResult = [Array<Asset>, bigint, bigint];
+
+export class AssetUtils {
+  static nextAsset<T extends Asset>({
+    allowedTokens,
+    selectedAssets,
+    balances,
+    tokensList,
+    prices = {},
+  }: NextAssetProps<T>): Address | undefined {
+    const selectedRecord = selectedAssets.reduce<Record<Address, true>>(
+      (acc, { token }) => {
+        acc[token.toLowerCase() as Address] = true;
+        return acc;
+      },
+      {},
+    );
+
+    const notSelected = allowedTokens.filter(allowedToken => {
+      const alreadySelected =
+        selectedRecord[allowedToken.toLowerCase() as Address];
+      return !alreadySelected;
+    });
+
+    const sorted = CreditAccountData_Legacy.sortBalances(
+      AssetUtils.getBalances(notSelected, balances),
+      prices,
+      tokensList,
+    );
+
+    const [address] = sorted[0] || [];
+
+    return address;
+  }
+
+  static getBalances(
+    allowedTokens: Array<Address>,
+    externalBalances: Record<Address, bigint>,
+  ): Record<Address, bigint> {
+    return allowedTokens.reduce((acc, address) => {
+      const addressLc = address.toLowerCase() as Address;
+      return {
+        ...acc,
+        [addressLc]: externalBalances[addressLc] || 0n,
+      };
+    }, {});
+  }
+
+  static constructAssetRecord<A extends Asset>(a: Array<A>) {
+    const record = a.reduce<Record<Address, A>>((acc, asset) => {
+      acc[asset.token] = asset;
+      return acc;
+    }, {});
+    return record;
+  }
+
+  static memoWrap = (
+    unwrappedAddress: Address,
+    wrappedAddress: Address,
+    prices: Record<Address, bigint>,
+    tokensList: Record<Address, TokenData>,
+  ) =>
+    function wrap(assets: Array<Asset>): WrapResult {
+      const assetsRecord = AssetUtils.constructAssetRecord(assets);
+
+      const unwrapped = assetsRecord[unwrappedAddress];
+
+      const wrapped = assetsRecord[wrappedAddress];
+      const { balance: wrappedAmount = 0n } = wrapped || {};
+
+      // if there unwrapped token
+      if (unwrapped) {
+        const { balance: unwrappedAmount = 0n } = unwrapped || {};
+
+        const unwrappedToken = tokensList[unwrappedAddress];
+        const unwrappedPrice = prices[unwrappedAddress] || 0n;
+
+        const wrappedToken = tokensList[wrappedAddress];
+        const wrappedPrice = prices[wrappedAddress] || 0n;
+
+        // convert unwrapped into wrapped by price
+        const unwrappedInWrapped = PriceUtils.convertByPrice(
+          PriceUtils.calcTotalPrice(
+            unwrappedPrice,
+            BigIntMath.max(0n, unwrappedAmount),
+            unwrappedToken.decimals,
+          ),
+          {
+            price: wrappedPrice,
+            decimals: wrappedToken.decimals,
+          },
+        );
+
+        // sum them
+        assetsRecord[wrappedAddress] = {
+          token: wrappedAddress,
+          balance: BigIntMath.max(0n, wrappedAmount) + unwrappedInWrapped,
+        };
+        // remove unwrapped
+        delete assetsRecord[unwrappedAddress];
+
+        return [Object.values(assetsRecord), unwrappedInWrapped, wrappedAmount];
+      }
+      // else no actions needed
+      return [Object.values(assetsRecord), 0n, wrappedAmount];
+    };
+
+  /**
+   * Sums the the second assets list into the first assets list
+   * Balances cant be negative; creates new assets.
+   */
+  static sumAssets<A extends Asset, B extends Asset>(
+    a: Array<A>,
+    b: Array<B>,
+  ): Array<A | B> {
+    const aRecord = AssetUtils.constructAssetRecord(a);
+
+    const resRecord = b.reduce<Record<Address, A | B>>((acc, bAsset) => {
+      const aAsset = acc[bAsset.token];
+      const { balance: amount = 0n } = aAsset || {};
+
+      const amountSum =
+        BigIntMath.max(0n, bAsset.balance) + BigIntMath.max(0n, amount);
+      const aOrB = aAsset || bAsset;
+
+      acc[bAsset.token] = {
+        ...aOrB,
+        balance: amountSum,
+      };
+
+      return acc;
+    }, aRecord);
+
+    return Object.values(resRecord);
+  }
+
+  /**
+   * Sums the the second assets list into the first assets list
+   * Balances cant be negative; doesn't create new assets.
+   */
+  static addBalances<A extends Asset, B extends Asset>(
+    a: Array<A>,
+    b: Array<B>,
+  ): Array<A | B> {
+    const bRecord = AssetUtils.constructAssetRecord(b);
+
+    return a.map(asset => {
+      const bAsset = bRecord[asset.token];
+      const { balance: bAmount = 0n } = bAsset || {};
+
+      const amountSum =
+        BigIntMath.max(0n, asset.balance) + BigIntMath.max(0n, bAmount);
+      return { ...asset, balance: amountSum };
+    });
+  }
+
+  /**
+   * Subtracts the the second assets list from the first assets list
+   * Balances cant be negative; doesn't create new assets.
+   */
+  static subAssets<A extends Asset, B extends Asset>(
+    a: Array<A>,
+    b: Array<B>,
+  ): Array<A> {
+    const bRecord = AssetUtils.constructAssetRecord(b);
+
+    return a.map(asset => {
+      const bAsset = bRecord[asset.token];
+      const { balance: bAmount = 0n } = bAsset || {};
+
+      const amountSub =
+        BigIntMath.max(0n, asset.balance) - BigIntMath.max(0n, bAmount);
+      return { ...asset, balance: BigIntMath.max(0n, amountSub) };
+    });
+  }
+}