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

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

@@ -0,0 +1,267 @@
+import type { Address } from "viem";
+
+import {
+  PERCENTAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  RAY,
+  SECONDS_PER_YEAR,
+  WAD,
+} from "../../constants";
+import type { Asset } from "../../router";
+import type { SupportedToken } from "../../sdk-gov-legacy";
+import { toBigInt } from "../../utils";
+import type { PoolData_Legacy } from "../core/pool";
+import type { TokenData } from "../tokens/tokenData";
+import { PriceUtils } from "../utils/price";
+import type { FarmInfo } from "./api";
+
+interface CalculateV3PoolLmAPYProps {
+  currentTimestamp: number;
+  info: FarmInfo;
+
+  supply: {
+    decimals: number;
+    amount: bigint;
+    price: bigint;
+  };
+
+  reward: {
+    decimals: number;
+    price: bigint;
+  };
+}
+
+const PERCENTAGE_FACTOR_1KK = PERCENTAGE_DECIMALS * PERCENTAGE_FACTOR;
+const ONE = PERCENTAGE_FACTOR_1KK * 10n;
+
+export interface ExtraRewardApy {
+  token: Address;
+  balance: bigint | null;
+
+  apy: number;
+  rewardToken: Address;
+  rewardTokenSymbol: string;
+}
+
+interface GetPoolExtraAPY_V3Props {
+  stakedDieselToken: Address | undefined;
+  pool: PoolData_Legacy;
+  prices: Record<Address, bigint>;
+
+  rewardPoolsInfo: Record<Address, Array<FarmInfo>>;
+  rewardPoolsSupply: Record<Address, bigint>;
+
+  tokensList: Record<Address, TokenData>;
+  currentTokenData: Record<SupportedToken, Address>;
+
+  currentTimestamp: number;
+}
+
+interface GetPoolExtraLmAPYProps
+  extends Omit<
+    GetPoolExtraAPY_V3Props,
+    "rewardPoolsInfo" | "stakedDieselToken"
+  > {
+  stakedDieselToken: Address;
+  rewardPoolsInfo: FarmInfo;
+}
+
+interface GetCAExtraAPYProps {
+  assets: Array<Asset>;
+  supply: Record<Address, bigint> | Record<Address, Asset>;
+  rewardInfo: Record<Address, Array<FarmInfo>>;
+  currentTimestamp: number;
+
+  prices: Record<Address, bigint>;
+  tokensList: Record<Address, TokenData>;
+  currentTokenData: Record<SupportedToken, Address>;
+}
+
+interface GetCASingleExtraAPYProps
+  extends Omit<GetCAExtraAPYProps, "rewardInfo" | "assets"> {
+  asset: Asset;
+  rewardInfo: FarmInfo;
+}
+
+export class GearboxRewardsApy {
+  static getPoolExtraAPY_V3({
+    rewardPoolsInfo,
+    stakedDieselToken,
+    ...restProps
+  }: GetPoolExtraAPY_V3Props): Array<ExtraRewardApy> {
+    const { version } = restProps.pool;
+    const isV3 = version >= 300 && version < 400;
+    if (!isV3 || !stakedDieselToken) return [];
+
+    const info = rewardPoolsInfo[stakedDieselToken];
+    if (!info) return [];
+
+    const extra = info.map(inf =>
+      this.getPoolSingleExtraLmAPY_V3({
+        ...restProps,
+        stakedDieselToken,
+        rewardPoolsInfo: inf,
+      }),
+    );
+
+    return extra;
+  }
+
+  private static getPoolSingleExtraLmAPY_V3({
+    stakedDieselToken,
+    pool,
+    prices,
+
+    rewardPoolsInfo,
+    rewardPoolsSupply,
+
+    tokensList,
+    currentTokenData,
+
+    currentTimestamp,
+  }: GetPoolExtraLmAPYProps): ExtraRewardApy {
+    const { underlyingToken, dieselRateRay } = pool;
+
+    const safeSupply = rewardPoolsSupply[stakedDieselToken] ?? 0n;
+
+    const { decimals: underlyingDecimals = 18 } =
+      tokensList[underlyingToken] || {};
+    const underlyingPrice = prices[underlyingToken] ?? 0n;
+    const dieselPrice = (underlyingPrice * dieselRateRay) / RAY;
+
+    const rewardAddress = currentTokenData[rewardPoolsInfo.symbol];
+    const { decimals: rewardDecimals = 18 } = tokensList[rewardAddress] || {};
+    const rewardPrice = prices[rewardAddress] ?? 0n;
+
+    const r =
+      this.calculateAPY_V3({
+        currentTimestamp,
+        info: rewardPoolsInfo,
+        supply: {
+          amount: safeSupply,
+          decimals: underlyingDecimals,
+          price: dieselPrice,
+        },
+        reward: {
+          price: rewardPrice,
+          decimals: rewardDecimals,
+        },
+      }) / Number(PERCENTAGE_FACTOR);
+
+    return {
+      token: stakedDieselToken,
+      balance: null,
+
+      apy: r,
+      rewardToken: rewardAddress,
+      rewardTokenSymbol: rewardPoolsInfo.symbol,
+    };
+  }
+
+  static calculateAPY_V3({
+    info,
+    supply,
+    reward,
+    currentTimestamp,
+  }: CalculateV3PoolLmAPYProps) {
+    const finished = info.finished <= currentTimestamp;
+    if (finished) return 0;
+
+    if (supply.amount <= 0n) return 0;
+    if (supply.price === 0n || reward.price === 0n) return 0;
+    if (info.duration === 0n) return 0;
+
+    const supplyMoney = PriceUtils.calcTotalPrice(
+      supply.price,
+      supply.amount,
+      supply.decimals,
+    );
+
+    const rewardMoney = PriceUtils.calcTotalPrice(
+      reward.price,
+      info.reward,
+      reward.decimals,
+    );
+
+    const durationRatio = (toBigInt(SECONDS_PER_YEAR) * WAD) / info.duration;
+
+    const apyBn = (((rewardMoney * ONE) / supplyMoney) * durationRatio) / WAD;
+
+    return Math.round(Number(apyBn) / 10);
+  }
+
+  static getCAExtraAPY_V3({
+    rewardInfo,
+    assets,
+    ...restProps
+  }: GetCAExtraAPYProps): Array<ExtraRewardApy> {
+    const extra = assets.reduce((acc, asset) => {
+      const { token } = asset;
+      const info = rewardInfo[token || ""];
+
+      if (!info || info.length === 0) return acc;
+
+      const extra = info.map(inf =>
+        this.getCASingleExtraAPY_V3({
+          ...restProps,
+          asset,
+          rewardInfo: inf,
+        }),
+      );
+
+      acc.push(...extra);
+
+      return acc;
+    }, [] as Array<ExtraRewardApy>);
+
+    return extra;
+  }
+
+  private static getCASingleExtraAPY_V3({
+    asset,
+    prices,
+    rewardInfo,
+    supply,
+
+    tokensList,
+    currentTokenData,
+
+    currentTimestamp,
+  }: GetCASingleExtraAPYProps): ExtraRewardApy {
+    const { token, balance } = asset;
+
+    const safeSupply = supply[token] ?? 0n;
+
+    const { decimals: tokenDecimals = 18 } = tokensList[token] || {};
+    const tokenPrice = prices[token] ?? 0n;
+
+    const rewardAddress = currentTokenData[rewardInfo.symbol];
+    const { decimals: rewardDecimals = 18 } = tokensList[rewardAddress] || {};
+    const rewardPrice = prices[rewardAddress] ?? 0n;
+
+    const r =
+      this.calculateAPY_V3({
+        currentTimestamp,
+        info: rewardInfo,
+        supply: {
+          amount:
+            typeof safeSupply === "bigint" ? safeSupply : safeSupply.balance,
+          decimals: tokenDecimals,
+          price: tokenPrice,
+        },
+        reward: {
+          price: rewardPrice,
+          decimals: rewardDecimals,
+        },
+      }) / Number(PERCENTAGE_FACTOR);
+
+    return {
+      token,
+      balance,
+
+      apy: r,
+      rewardToken: rewardAddress,
+      rewardTokenSymbol: rewardInfo.symbol,
+    };
+  }
+}

package/src/sdk/sdk-legacy/gearboxRewards/extraAPY.ts

@@ -0,0 +1,165 @@
+import axios from "axios";
+import type { Address } from "viem";
+
+import type { NetworkType } from "../../chain";
+import { chains } from "../../chain";
+import { PERCENTAGE_FACTOR } from "../../constants";
+import type { Asset } from "../../router";
+import { GearboxBackendApi } from "../core/endpoint";
+import type { PoolData_Legacy } from "../core/pool";
+import type { TokenData } from "../tokens/tokenData";
+import { toBN } from "../utils/formatter";
+import { BigIntMath } from "../utils/math";
+
+export interface PoolPointsInfo {
+  pool: Address;
+  token: Address;
+  symbol: string;
+
+  amount: bigint;
+  duration: string;
+  name: string;
+  estimation: "absolute" | "relative";
+}
+
+export interface GetPointsByPoolProps {
+  poolRewards: Record<Address, Record<Address, PoolPointsInfo>>;
+
+  totalTokenBalances: Record<Address, Asset>;
+  pools: Array<PoolData_Legacy>;
+  tokensList: Record<Address, TokenData>;
+}
+
+interface WalletResult {
+  borrower: Address;
+  effective_balance: number;
+}
+
+interface GetBalanceAtResponse {
+  result: Array<WalletResult>;
+}
+
+export interface GetTotalTokensOnProtocolProps {
+  tokensToCheck: Array<Address>;
+
+  tokensList: Record<Address, TokenData>;
+  network: NetworkType;
+}
+
+export class GearboxRewardsExtraApy {
+  static async getTotalTokensOnProtocol({
+    tokensToCheck,
+
+    tokensList,
+    network,
+  }: GetTotalTokensOnProtocolProps) {
+    const list = [...new Set(tokensToCheck)];
+
+    const res = await Promise.allSettled(
+      list.map(t => this.getTokenTotal(t, network, tokensList)),
+    );
+
+    return res.map((r, i): [Address, PromiseSettledResult<Asset>] => [
+      list[i],
+      r,
+    ]);
+  }
+
+  private static async getTokenTotal(
+    token: Address,
+    network: NetworkType,
+    tokensList: Record<Address, TokenData>,
+  ) {
+    const chainId = chains[network]?.id;
+
+    const url = GearboxBackendApi.getChartsUrl("getBalanceAt", chainId, {
+      params: {
+        asset: token,
+      },
+    });
+
+    const result = await axios.get<GetBalanceAtResponse>(url);
+    const balance = result.data.result.reduce(
+      (sum, r) => r.effective_balance + sum,
+      0,
+    );
+    const { decimals = 18 } = tokensList[token] || {};
+
+    return { token, balance: toBN(String(balance), decimals) };
+  }
+
+  static getPointsByPool({
+    poolRewards,
+
+    totalTokenBalances,
+    pools,
+    tokensList,
+  }: GetPointsByPoolProps) {
+    const r = pools.reduce<Record<Address, Array<Asset>>>((acc, p) => {
+      const pointsInfo = Object.values(poolRewards[p.address] || {});
+
+      const poolPointsList = pointsInfo.reduce<Array<Asset>>(
+        (acc, pointsInfo) => {
+          const { address: tokenAddress } = tokensList[pointsInfo.token];
+          const tokenBalance = totalTokenBalances[tokenAddress || ""];
+
+          const points = this.getPoolTokenPoints(
+            tokenBalance,
+            p,
+            tokensList,
+            pointsInfo,
+          );
+
+          if (points !== null) {
+            acc.push({ balance: points, token: tokenBalance.token });
+          }
+
+          return acc;
+        },
+        [],
+      );
+
+      acc[p.address] = poolPointsList;
+
+      return acc;
+    }, {});
+
+    return r;
+  }
+
+  private static getPoolTokenPoints(
+    tokenBalanceInPool: Asset | undefined,
+    pool: PoolData_Legacy,
+    tokensList: Record<Address, TokenData>,
+    pointsInfo: PoolPointsInfo,
+  ) {
+    if (!tokenBalanceInPool) return null;
+    if (pool.expectedLiquidity <= 0) return 0n;
+    const { decimals = 18 } = tokensList[tokenBalanceInPool.token] || {};
+    const targetFactor = 10n ** BigInt(decimals);
+
+    const { decimals: underlyingDecimals = 18 } =
+      tokensList[pool.underlyingToken] || {};
+    const underlyingFactor = 10n ** BigInt(underlyingDecimals);
+
+    const defaultPoints =
+      (pointsInfo.amount * targetFactor) / PERCENTAGE_FACTOR;
+
+    const points =
+      pointsInfo.estimation === "absolute"
+        ? defaultPoints
+        : (tokenBalanceInPool.balance * defaultPoints) /
+          ((pool.expectedLiquidity * targetFactor) / underlyingFactor);
+
+    return BigIntMath.min(points, defaultPoints);
+  }
+
+  static getPoolPointsTip(
+    poolRewards: Record<Address, Record<Address, PoolPointsInfo>>,
+    pool: Address,
+    token: Address,
+  ) {
+    const p = poolRewards[pool]?.[token];
+    return p;
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from "./api";
+export * from "./apy";
+export * from "./extraAPY";

package/src/sdk/sdk-legacy/gearboxRewards/merklAPI.ts

@@ -0,0 +1,151 @@
+import type { Address } from "viem";
+
+import type { BigNumberish } from "../utils/formatter";
+
+interface UserOptions {
+  params: {
+    user: string;
+    chainId: number;
+  };
+}
+
+export interface MerkleXYZUserRewardsV4 {
+  chain: MerkleXYZChain;
+  rewards: Array<{
+    root: Address;
+    recipient: Address;
+    amount: BigNumberish;
+    claimed: BigNumberish;
+    pending: BigNumberish;
+    proofs: Array<Address>;
+    token: {
+      address: Address;
+      chainId: number;
+      symbol: string;
+      decimals: number;
+    };
+    breakdowns: Array<{
+      reason: string;
+      amount: BigNumberish;
+      claimed: BigNumberish;
+      pending: BigNumberish;
+      campaignId: Address;
+    }>;
+  }>;
+}
+export type MerkleXYZUserRewardsV4Response = Array<MerkleXYZUserRewardsV4>;
+
+interface MerkleXYZChain {
+  id: number;
+  name: string;
+  icon: string;
+}
+
+interface MerkleXYZToken {
+  id: string;
+  name: string;
+  chainId: number;
+  address: Address;
+  decimals: number;
+  icon: string;
+  verified: boolean;
+  isTest: boolean;
+  price: number | null;
+  symbol: string;
+}
+
+export interface MerklXYZV4Campaign {
+  chainId: number;
+  type: string;
+  identifier: Address;
+  name: string;
+  status: "LIVE" | "PAST";
+  action: "LEND" | "BORROW";
+  tvl: number;
+  apr: number;
+  dailyRewards: number;
+  tags: Array<string>;
+  id: string;
+  tokens: Array<MerkleXYZToken>;
+  chain: MerkleXYZChain;
+  aprRecord: {
+    cumulated: number;
+    timestamp: string;
+    breakdowns: Array<{
+      id: number;
+      identifier: Address;
+      type: "CAMPAIGN";
+      value: number;
+      aprRecordId: string;
+    }>;
+  };
+  tvlRecord: {
+    id: string;
+    total: number;
+    timestamp: string;
+    breakdowns: [];
+  };
+  rewardsRecord: {
+    id: string;
+    total: number;
+    timestamp: string;
+    breakdowns: Array<{
+      token: MerkleXYZToken;
+      amount: string;
+      id: number;
+      value: number;
+      campaignId: string;
+      dailyRewardsRecordid: string;
+    }>;
+  };
+}
+export type MerkleXYZV4CampaignsResponse = Array<MerklXYZV4Campaign>;
+
+export interface MerklXYZV4RewardCampaign {
+  id: string;
+  computeChainId: number;
+  distributionChainId: number;
+  campaignId: Address;
+  rewardTokenId: string;
+  amount: string;
+  opportunityId: string;
+  startTimestamp: string;
+  endTimestamp: string;
+  creatorAddress: Address;
+  params: {
+    url: string;
+    duration: number;
+    blacklist: Array<Address>;
+    whitelist: Array<Address>;
+    forwarders: Array<Address>;
+    targetToken: Address;
+    symbolRewardToken: string;
+    symbolTargetToken: string;
+    decimalsRewardToken: number;
+    decimalsTargetToken: number;
+  };
+  chain: MerkleXYZChain;
+  rewardToken: MerkleXYZToken;
+  distributionChain: MerkleXYZChain;
+  campaignStatus: {
+    campaignId: string;
+    computedUntil: string;
+    processingStarted: string;
+    status: "SUCCESS";
+    error: string;
+    details: string;
+  };
+}
+export type MerkleXYZV4RewardCampaignResponse = Array<MerklXYZV4RewardCampaign>;
+
+// https://api.merkl.xyz/v3/campaignsForMainParameter?chainId=1&mainParameter=0xE2037090f896A858E3168B978668F22026AC52e7
+
+export class MerkleXYZApi {
+  static getUserRewardsUrl = (options: UserOptions) =>
+    `https://api.merkl.xyz/v4/users/${options.params.user}/rewards?chainId=${options.params.chainId}`;
+
+  static getGearboxCampaignsUrl = () =>
+    "https://api.merkl.xyz/v4/opportunities?name=gearbox";
+  static getGearboxRewardCampaignUrl = (campaignId: Address) =>
+    `https://api.merkl.xyz/v4/campaigns?campaignId=${campaignId}`;
+}

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

@@ -0,0 +1,21 @@
+export * from "./apy";
+export * from "./core/assets";
+export * from "./core/creditAccount";
+export * from "./core/creditManager";
+export * from "./core/creditSession";
+export * from "./core/endpoint";
+export * from "./core/eventOrTx";
+export * from "./core/pool";
+export * from "./core/strategy";
+export * from "./core/transactions";
+export * from "./gearboxRewards";
+export * from "./pathfinder";
+export * from "./payload/creditAccount";
+export * from "./payload/creditManager";
+export * from "./payload/creditSession";
+export * from "./payload/graphPayload";
+export * from "./payload/pool";
+export * from "./payload/token";
+export * from "./tokens/tokenData";
+export * from "./types";
+export * from "./utils";

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

@@ -0,0 +1,18 @@
+import type { Address } from "viem";
+
+import type { MultiCall } from "../../types";
+
+export interface PathFinderResult {
+  amount: bigint;
+  minAmount: bigint;
+  calls: MultiCall[];
+}
+
+export interface PathFinderOpenStrategyResult extends PathFinderResult {
+  balances: Record<Address, bigint>;
+  minBalances: Record<Address, bigint>;
+}
+
+export interface PathFinderCloseResult extends PathFinderResult {
+  underlyingBalance: bigint;
+}

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

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

package/src/sdk/sdk-legacy/payload/creditAccount.ts

@@ -0,0 +1,48 @@
+import type { Address } from "viem";
+
+import type { ConnectedBotData } from "../../base";
+
+export interface CaTokenBalance {
+  success: boolean;
+  token: Address;
+  balance: bigint;
+  isForbidden: boolean;
+  isEnabled: boolean;
+  isQuoted: boolean;
+  quota: bigint;
+  quotaRate: bigint;
+  mask: bigint;
+}
+
+export interface CreditAccountDataPayload {
+  isSuccessful: boolean;
+  addr: Address;
+  borrower: Address;
+  creditManager: Address;
+  creditFacade: Address;
+  underlying: Address;
+  debt: bigint;
+  accruedInterest: bigint;
+  accruedFees: bigint;
+  totalDebtUSD: bigint;
+  totalValue: bigint;
+  totalValueUSD: bigint;
+  twvUSD: bigint;
+  enabledTokensMask: bigint;
+  healthFactor: bigint;
+  baseBorrowRate: bigint;
+  balances: readonly {
+    success: boolean;
+    token: Address;
+    balance: bigint;
+    isForbidden: boolean;
+    isEnabled: boolean;
+    isQuoted: boolean;
+    quota: bigint;
+    quotaRate: number;
+    mask: bigint;
+  }[];
+  cfVersion: bigint;
+  expirationDate: number;
+  activeBots: ConnectedBotData[];
+}