@gearbox-protocol/sdk 13.3.0-next.2 → 13.3.0

package/dist/esm/{sdk/market/ZapperRegister.js → plugins/zappers/extraZappers.js}

@@ -1,110 +1,4 @@
-import { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
-import { SDKConstruct } from "../base/index.js";
-import {
-  AP_PERIPHERY_COMPRESSOR,
-  VERSION_RANGE_310
-} from "../constants/index.js";
-import { AddressMap, hexEq } from "../utils/index.js";
-class ZapperRegister extends SDKConstruct {
-  /**
-   * Mapping pool.address -> ZapperData[]
-   * Needs to be loaded explicitly using loadZappers method
-   */
-  #zappers;
-  /**
-   * Load zappers for all pools using periphery compressor, adds hardcoded zappers
-   */
-  async loadZappers(force) {
-    if (!force && this.#zappers) {
-      return;
-    }
-    const [pcAddr] = this.sdk.addressProvider.mustGetLatest(
-      AP_PERIPHERY_COMPRESSOR,
-      VERSION_RANGE_310
-    );
-    this.logger?.debug(`loading zappers with periphery compressor ${pcAddr}`);
-    const markets = this.sdk.marketRegister.markets;
-    const resp = await this.client.multicall({
-      contracts: markets.map(
-        (m) => ({
-          abi: peripheryCompressorAbi,
-          address: pcAddr,
-          functionName: "getZappers",
-          args: [m.configurator.address, m.pool.pool.address]
-        })
-      ),
-      allowFailure: true,
-      batchSize: 0
-    });
-    this.#zappers = new AddressMap(void 0, "zappers");
-    for (let i = 0; i < resp.length; i++) {
-      const { status, result, error } = resp[i];
-      const marketConfigurator = markets[i].configurator.address;
-      const pool = markets[i].pool.pool.address;
-      if (status === "success") {
-        for (const z of result) {
-          this.#addZapper({ ...z, pool, type: "base" });
-        }
-      } else {
-        this.logger?.error(
-          `failed to load zapper for market configurator ${this.labelAddress(
-            marketConfigurator
-          )} and pool ${this.labelAddress(pool)}: ${error}`
-        );
-      }
-    }
-    for (const z of KYC_ZAPPERS[this.networkType] ?? []) {
-      this.#addZapper({ ...z, type: "kyc" });
-    }
-    for (const z of MIGRATION_ZAPPERS[this.networkType] ?? []) {
-      this.#addZapper({ ...z, type: "migration" });
-    }
-  }
-  #addZapper(z) {
-    if (BROKEN_ZAPPERS.has(z.baseParams.addr)) {
-      return;
-    }
-    const existing = this.zappers.get(z.pool);
-    if (existing) {
-      const hasZapper = existing.some(
-        (zz) => hexEq(zz.baseParams.addr, z.baseParams.addr)
-      );
-      if (!hasZapper) {
-        existing.push(z);
-      }
-    } else {
-      this.zappers.upsert(z.pool, [z]);
-    }
-    const zappersTokens = [z.tokenIn, z.tokenOut];
-    for (const t of zappersTokens) {
-      this.sdk.tokensMeta.upsert(t.addr, t);
-      this.sdk.setAddressLabel(t.addr, t.symbol);
-    }
-  }
-  get zappers() {
-    if (!this.#zappers) {
-      throw new Error("zappers not loaded, call loadZappers first");
-    }
-    return this.#zappers;
-  }
-  poolZappers(pool) {
-    return this.zappers.get(pool) ?? [];
-  }
-  /**
-   * Can return multiple zappers if there are multiple zappers for the same tokenIn and tokenOut
-   */
-  getZapper(pool, tokenIn, tokenOut) {
-    const zappers = this.zappers.get(pool)?.filter(
-      (z) => hexEq(z.tokenIn.addr, tokenIn) && hexEq(z.tokenOut.addr, tokenOut)
-    );
-    return zappers;
-  }
-}
-const BROKEN_ZAPPERS = new AddressMap(
-  [["0x90D66b03EC4D462e42e3c7741049FB46a4a03B69", true]],
-  "brokenZappers"
-);
-const MIGRATION_ZAPPERS = {
+const extraZappers = {
   Mainnet: [
     {
       baseParams: {
@@ -213,7 +107,6 @@ const MIGRATION_ZAPPERS = {
     }
   ]
 };
-const KYC_ZAPPERS = {};
 export {
-  ZapperRegister
+  extraZappers
 };

package/dist/esm/plugins/zappers/index.js

@@ -0,0 +1,3 @@
+export * from "./extraZappers.js";
+export * from "./types.js";
+export * from "./ZappersPlugin.js";

package/dist/esm/plugins/zappers/package.json

@@ -0,0 +1 @@
+{"type": "module","sideEffects":false}

package/dist/esm/rewards/apy/index.js

@@ -0,0 +1,2 @@
+export * from "./output.js";
+export * from "./output-details.js";

package/dist/esm/rewards/index.js

@@ -0,0 +1,2 @@
+export * from "./apy/index.js";
+export * from "./rewards/index.js";

package/dist/esm/rewards/package.json

@@ -0,0 +1 @@
+{"type": "module","sideEffects":false}

package/dist/esm/rewards/rewards/api.js

@@ -0,0 +1,204 @@
+import { getAddress, getContract } from "viem";
+import { iFarmingPoolAbi } from "../../abi/iFarmingPool.js";
+import { BigIntMath } from "../../common-utils/index.js";
+import { chains, toBigInt } from "../../sdk/index.js";
+import {
+  MerkleXYZApi
+} from "./merkl-api.js";
+class GearboxRewardsApi {
+  constructor() {
+  }
+  static async getLmRewardsV3({
+    pools,
+    tokensList,
+    provider,
+    account,
+    reportError
+  }) {
+    const poolByStakedDiesel = Object.values(pools).reduce((acc, p) => {
+      p.stakedDieselToken.forEach((t) => {
+        if (t) acc[t] = p.address;
+      });
+      p.stakedDieselToken_old.forEach((t) => {
+        if (t) acc[t] = p.address;
+      });
+      return acc;
+    }, {});
+    const stakedDieselTokens = Object.keys(poolByStakedDiesel);
+    const farmInfoCalls = stakedDieselTokens.map((address) => ({
+      address,
+      abi: iFarmingPoolAbi,
+      functionName: "farmInfo",
+      args: []
+    }));
+    const rewardTokenCalls = stakedDieselTokens.map((address) => ({
+      address,
+      abi: POOL_REWARDS_ABI,
+      functionName: "rewardsToken",
+      args: []
+    }));
+    const farmedCalls = stakedDieselTokens.map((address) => ({
+      address,
+      abi: iFarmingPoolAbi,
+      functionName: "farmed",
+      args: [account]
+    }));
+    const [response] = await Promise.allSettled([
+      provider.multicall({
+        allowFailure: false,
+        contracts: [...farmInfoCalls, ...rewardTokenCalls, ...farmedCalls],
+        batchSize: 0
+      })
+    ]);
+    const safeResponse = GearboxRewardsApi.extractFulfilled(response, reportError, "v3Rewards") || [];
+    const farmInfoCallsEnd = farmInfoCalls.length;
+    const farmInfo = safeResponse.slice(
+      0,
+      farmInfoCallsEnd
+    );
+    const rewardTokenCallsEnd = farmInfoCallsEnd + rewardTokenCalls.length;
+    const rewardTokens = safeResponse.slice(
+      farmInfoCallsEnd,
+      rewardTokenCallsEnd
+    );
+    const farmedCallsEnd = rewardTokenCallsEnd + farmedCalls.length;
+    const farmedList = safeResponse.slice(
+      rewardTokenCallsEnd,
+      farmedCallsEnd
+    );
+    const gearboxLmRewards = stakedDieselTokens.map(
+      (address, i) => {
+        const pool = poolByStakedDiesel[address];
+        const info = farmInfo[i];
+        const rewardToken = rewardTokens[i]?.toLowerCase();
+        const farmed = farmedList[i];
+        if (!pool || !info || !rewardToken) return void 0;
+        return {
+          pool,
+          poolToken: address,
+          rewardToken,
+          rewardTokenDecimals: tokensList[rewardToken]?.decimals || 18,
+          rewardTokenSymbol: tokensList[rewardToken]?.symbol || "unknown",
+          amount: farmed ?? 0n,
+          type: "stakedV3"
+        };
+      }
+    );
+    const { zero, nonZero } = gearboxLmRewards.reduce(
+      (acc, r) => {
+        if (r && r.amount > 0n) {
+          acc.nonZero.push(r);
+        } else if (r) {
+          acc.zero.push(r);
+        }
+        return acc;
+      },
+      { nonZero: [], zero: [] }
+    );
+    return [...nonZero, zero];
+  }
+  static async getLmRewardsMerkle({
+    pools,
+    account,
+    network,
+    reportError
+  }) {
+    const [merkleXYZLMResponse] = await Promise.allSettled([
+      MerkleXYZApi.fetchWithFallback(
+        MerkleXYZApi.getUserRewardsUrl({
+          params: {
+            chainId: chains[network].id,
+            user: getAddress(account)
+          }
+        })
+      )
+    ]);
+    const merkleXYZLm = GearboxRewardsApi.extractFulfilled(
+      merkleXYZLMResponse,
+      reportError,
+      "merkleXYZLm"
+    )?.data;
+    const poolByItsToken = Object.values(pools).reduce((acc, p) => {
+      p.stakedDieselToken.forEach((t) => {
+        if (t) acc[t] = p.address;
+      });
+      p.stakedDieselToken_old.forEach((t) => {
+        if (t) acc[t] = p.address;
+      });
+      acc[p.dieselToken] = p.address;
+      return acc;
+    }, {});
+    const extraRewards = (merkleXYZLm || []).reduce((acc, chainRewards) => {
+      chainRewards.rewards.forEach((reward) => {
+        const rewardToken = reward.token.address.toLowerCase();
+        reward.breakdowns.forEach((reason) => {
+          const poolToken = ((reason.reason || "").split("_").find((part) => part.startsWith("0x")) || "").toLowerCase();
+          const pool = poolByItsToken[poolToken];
+          const total = toBigInt(reason.amount || 0);
+          const claimed = toBigInt(reason.claimed || 0);
+          const claimable = BigIntMath.max(total - claimed, 0n);
+          const key = [pool, poolToken, rewardToken].join("_");
+          if (pool && claimable > 0n) {
+            const prevAmount = acc[key]?.amount || 0n;
+            acc[key] = {
+              pool,
+              poolToken,
+              rewardToken,
+              rewardTokenSymbol: reward.token.symbol,
+              rewardTokenDecimals: reward.token.decimals || 18,
+              amount: prevAmount + claimable,
+              type: "extraMerkle"
+            };
+          }
+        });
+      });
+      return acc;
+    }, {});
+    return Object.values(extraRewards);
+  }
+  static extractFulfilled(r, reportError, description) {
+    if (r.status === "fulfilled") {
+      return r.value;
+    } else {
+      if (reportError) {
+        reportError(r.reason, description);
+      } else {
+        console.error(r.reason);
+      }
+      return void 0;
+    }
+  }
+  static async claimLmRewardsV3({
+    reward,
+    signer,
+    account
+  }) {
+    const pool = getContract({
+      address: reward.poolToken,
+      abi: iFarmingPoolAbi,
+      client: signer
+    });
+    return pool.write.claim({
+      account,
+      chain: signer.chain
+    });
+  }
+}
+const POOL_REWARDS_ABI = [
+  {
+    inputs: [],
+    name: "rewardsToken",
+    outputs: [
+      {
+        internalType: "contract IERC20",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+export {
+  GearboxRewardsApi
+};

package/dist/esm/rewards/rewards/apy.js

@@ -0,0 +1,160 @@
+import { PriceUtils } from "../../common-utils/index.js";
+import {
+  PERCENTAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  RAY,
+  SECONDS_PER_YEAR,
+  toBigInt,
+  WAD
+} from "../../sdk/index.js";
+const PERCENTAGE_FACTOR_1KK = PERCENTAGE_DECIMALS * PERCENTAGE_FACTOR;
+const ONE = PERCENTAGE_FACTOR_1KK * 10n;
+class GearboxRewardsApy {
+  constructor() {
+  }
+  static getPoolExtraAPY_V3({
+    rewardPoolsInfo,
+    stakedDieselToken,
+    ...restProps
+  }) {
+    const { version } = restProps.pool;
+    const isV3 = version >= 300 && version < 400;
+    if (!isV3 || !stakedDieselToken) return [];
+    const info = rewardPoolsInfo[stakedDieselToken];
+    if (!info) return [];
+    const extra = (Array.isArray(info) ? info : [info]).map(
+      (inf) => GearboxRewardsApy.getPoolSingleExtraLmAPY_V3({
+        ...restProps,
+        stakedDieselToken,
+        rewardPoolsInfo: inf
+      })
+    );
+    return extra;
+  }
+  static getPoolSingleExtraLmAPY_V3({
+    stakedDieselToken,
+    pool,
+    prices,
+    rewardPoolsInfo,
+    rewardPoolsSupply,
+    tokensList,
+    currentTimestamp
+  }) {
+    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 = rewardPoolsInfo?.token || "";
+    const { decimals: rewardDecimals = 18 } = tokensList[rewardAddress] || {};
+    const rewardPrice = prices[rewardAddress] ?? 0n;
+    const r = GearboxRewardsApy.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
+  }) {
+    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
+  }) {
+    const extra = assets.reduce(
+      (acc, asset) => {
+        const { token } = asset;
+        const info = rewardInfo[token || ""];
+        if (!info || info.length === 0) return acc;
+        const extra2 = info.map(
+          (inf) => GearboxRewardsApy.getCASingleExtraAPY_V3({
+            ...restProps,
+            asset,
+            rewardInfo: inf
+          })
+        );
+        acc.push(...extra2);
+        return acc;
+      },
+      []
+    );
+    return extra;
+  }
+  static getCASingleExtraAPY_V3({
+    asset,
+    prices,
+    rewardInfo,
+    supply,
+    tokensList,
+    currentTimestamp
+  }) {
+    const { token, balance } = asset;
+    const safeSupply = supply[token] ?? 0n;
+    const { decimals: tokenDecimals = 18 } = tokensList[token] || {};
+    const tokenPrice = prices[token] ?? 0n;
+    const rewardAddress = rewardInfo?.token || "";
+    const { decimals: rewardDecimals = 18 } = tokensList[rewardAddress] || {};
+    const rewardPrice = prices[rewardAddress] ?? 0n;
+    const r = GearboxRewardsApy.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
+    };
+  }
+}
+export {
+  GearboxRewardsApy
+};

package/dist/esm/rewards/rewards/extra-apy.js

@@ -0,0 +1,101 @@
+import axios from "axios";
+import { BigIntMath } from "../../common-utils/index.js";
+import {
+  chains,
+  PERCENTAGE_FACTOR,
+  toBN
+} from "../../sdk/index.js";
+function getKeyForPoolPointsInfo(i) {
+  return [
+    i.pool,
+    i.token,
+    i.symbol,
+    i.duration,
+    i.name,
+    i.type,
+    i.estimation,
+    i.condition
+  ].join("-");
+}
+class GearboxRewardsExtraApy {
+  constructor() {
+  }
+  static async getTotalTokensOnProtocol({
+    tokensToCheck,
+    tokensList,
+    network
+  }) {
+    const list = [...new Set(tokensToCheck)];
+    const res = await Promise.allSettled(
+      list.map(
+        (t) => GearboxRewardsExtraApy.getTokenTotal(t, network, tokensList)
+      )
+    );
+    return res.map((r, i) => [
+      list[i],
+      r
+    ]);
+  }
+  static async getTokenTotal(token, network, tokensList) {
+    const chainId = chains[network]?.id;
+    const url = `https://charts-server.fly.dev/api/getBalanceAt?asset=${token}&chainId=${chainId}`;
+    const result = await axios.get(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
+  }) {
+    const r = pools.reduce((acc, p) => {
+      const pointsInfo = poolRewards[p.address] || [];
+      const poolPointsList = pointsInfo.reduce(
+        (acc2, pointsInfo2) => {
+          const { address: tokenAddress } = tokensList[pointsInfo2.token] || {};
+          const tokenBalance = totalTokenBalances[tokenAddress || ""];
+          const points = GearboxRewardsExtraApy.getPoolTokenPoints(
+            tokenBalance,
+            p,
+            tokensList,
+            pointsInfo2
+          );
+          if (points !== null) {
+            acc2.push({
+              key: getKeyForPoolPointsInfo(pointsInfo2),
+              info: pointsInfo2,
+              points
+            });
+          }
+          return acc2;
+        },
+        []
+      );
+      acc[p.address] = poolPointsList;
+      return acc;
+    }, {});
+    return r;
+  }
+  static getPoolTokenPoints(tokenBalanceInPool, pool, tokensList, pointsInfo) {
+    if (pool.expectedLiquidity <= 0) return 0n;
+    if (pointsInfo.estimation === "relative" && !tokenBalanceInPool)
+      return null;
+    const { decimals = 18 } = tokensList[pointsInfo.token] || {};
+    const targetFactor = 10n ** BigInt(decimals);
+    const defaultPoints = pointsInfo.amount * targetFactor / PERCENTAGE_FACTOR;
+    if (pointsInfo.estimation === "absolute") return defaultPoints;
+    const { decimals: underlyingDecimals = 18 } = tokensList[pool.underlyingToken] || {};
+    const underlyingFactor = 10n ** BigInt(underlyingDecimals);
+    const points = (tokenBalanceInPool?.balance || 0n) * defaultPoints / (pool.expectedLiquidity * targetFactor / underlyingFactor);
+    return BigIntMath.min(points, defaultPoints);
+  }
+}
+export {
+  GearboxRewardsExtraApy,
+  getKeyForPoolPointsInfo
+};

package/dist/esm/rewards/rewards/index.js

@@ -0,0 +1,4 @@
+export * from "./api.js";
+export * from "./apy.js";
+export * from "./extra-apy.js";
+export * from "./merkl-api.js";

package/dist/esm/rewards/rewards/merkl-api.js

@@ -0,0 +1,18 @@
+import axios from "axios";
+class MerkleXYZApi {
+  constructor() {
+  }
+  static defaultDomain = "https://api.merkl.xyz";
+  static angleDomain = "https://api-merkl.angle.money";
+  static fetchWithFallback = async (getUrl) => {
+    try {
+      return await axios.get(getUrl(MerkleXYZApi.defaultDomain));
+    } catch {
+      return await axios.get(getUrl(MerkleXYZApi.angleDomain));
+    }
+  };
+  static getUserRewardsUrl = (options) => (domain) => `${domain}/v4/users/${options.params.user}/rewards?chainId=${options.params.chainId}`;
+}
+export {
+  MerkleXYZApi
+};