@gearbox-protocol/sdk 15.0.0-next.2 → 15.0.0-pyth.1

package/dist/esm/plugins/adapters/contracts/index.js

@@ -28,9 +28,13 @@ export * from "./MellowDVVAdapterContract.js";
 export * from "./MellowERC4626VaultAdapterContract.js";
 export * from "./MellowRedeemQueueAdapterContract.js";
 export * from "./MellowWrapperAdapterContract.js";
+export * from "./MidasGatewayAdapterContract.js";
 export * from "./MidasIssuanceVaultAdapterContract.js";
 export * from "./MidasRedemptionVaultAdapterContract.js";
 export * from "./PendleRouterAdapterContract.js";
+export * from "./SecuritizeOnRampAdapterContract.js";
+export * from "./SecuritizeRedemptionGatewayAdapterContract.js";
+export * from "./SecuritizeSwapAdapterContract.js";
 export * from "./StakingRewardsAdapterContract.js";
 export * from "./TraderJoeRouterAdapterContract.js";
 export * from "./UniswapV2AdapterContract.js";

package/dist/esm/plugins/adapters/createAdapter.js

@@ -40,6 +40,10 @@ import {
   VelodromeV2RouterAdapterContract,
   WstETHV1AdapterContract
 } from "./contracts/index.js";
+import { MidasGatewayAdapterContract } from "./contracts/MidasGatewayAdapterContract.js";
+import { SecuritizeOnRampAdapterContract } from "./contracts/SecuritizeOnRampAdapterContract.js";
+import { SecuritizeRedemptionGatewayAdapterContract } from "./contracts/SecuritizeRedemptionGatewayAdapterContract.js";
+import { SecuritizeSwapAdapterContract } from "./contracts/SecuritizeSwapAdapterContract.js";
 import { UniswapV4AdapterContract } from "./contracts/UniswapV4AdapterContract.js";
 function createAdapter(options, data, strict) {
   const contractType = data.baseParams.contractType;
@@ -105,8 +109,16 @@ function createAdapter(options, data, strict) {
       return new MidasIssuanceVaultAdapterContract(options, data);
     case "ADAPTER::MIDAS_REDEMPTION_VAULT":
       return new MidasRedemptionVaultAdapterContract(options, data);
+    case "ADAPTER::MIDAS_GATEWAY":
+      return new MidasGatewayAdapterContract(options, data);
     case "ADAPTER::PENDLE_ROUTER":
       return new PendleRouterAdapterContract(options, data);
+    case "ADAPTER::SECURITIZE_ONRAMP":
+      return new SecuritizeOnRampAdapterContract(options, data);
+    case "ADAPTER::SECURITIZE_REDEMPTION":
+      return new SecuritizeRedemptionGatewayAdapterContract(options, data);
+    case "ADAPTER::SECURITIZE_SWAP":
+      return new SecuritizeSwapAdapterContract(options, data);
     case "ADAPTER::STAKING_REWARDS":
       return new StakingRewardsAdapterContract(options, data);
     case "ADAPTER::TRADER_JOE_ROUTER":

package/dist/esm/plugins/adapters/types.js

@@ -34,7 +34,11 @@ var AdapterType = /* @__PURE__ */ ((AdapterType2) => {
   AdapterType2["MELLOW_REDEEM_QUEUE"] = "MELLOW_REDEEM_QUEUE";
   AdapterType2["MIDAS_ISSUANCE_VAULT"] = "MIDAS_ISSUANCE_VAULT";
   AdapterType2["MIDAS_REDEMPTION_VAULT"] = "MIDAS_REDEMPTION_VAULT";
+  AdapterType2["MIDAS_GATEWAY"] = "MIDAS_GATEWAY";
   AdapterType2["PENDLE_ROUTER"] = "PENDLE_ROUTER";
+  AdapterType2["SECURITIZE_ONRAMP"] = "SECURITIZE_ONRAMP";
+  AdapterType2["SECURITIZE_REDEMPTION"] = "SECURITIZE_REDEMPTION";
+  AdapterType2["SECURITIZE_SWAP"] = "SECURITIZE_SWAP";
   AdapterType2["STAKING_REWARDS"] = "STAKING_REWARDS";
   AdapterType2["TRADER_JOE_ROUTER"] = "TRADER_JOE_ROUTER";
   AdapterType2["UNISWAP_V2_ROUTER"] = "UNISWAP_V2_ROUTER";

package/dist/esm/plugins/apy/ApyPlugin.js

@@ -1,4 +1,11 @@
 import { marketCompressorAbi } from "../../abi/compressors/marketCompressor.js";
+import { AxiosCache } from "../../common-utils/axios-cache/index.js";
+import {
+  getAvailableAndDisabledStrategies,
+  getReleasedStrategiesListCore,
+  getStrategyCreditManagersListCore,
+  getStrategyInfoCore
+} from "../../common-utils/utils/strategies/index.js";
 import { PoolPointsAPI } from "../../rewards/rewards/extra-apy.js";
 import {
   AddressMap,
@@ -10,7 +17,6 @@ import {
 } from "../../sdk/index.js";
 import { rayToNumber } from "../../sdk/utils/formatter.js";
 import { hexEq } from "../../sdk/utils/hex.js";
-import { ApyOutputCache } from "./apy-cache.js";
 import { parseGearStats, parseNetworkApy } from "./apy-parser.js";
 import { APY_STATE_CACHE_URL, DEFAULT_APY_INTERVAL_MS } from "./constants.js";
 import {
@@ -20,6 +26,7 @@ import {
   calculateSupplyApy7d,
   getPoolExtraAPY
 } from "./pool-apy-utils.js";
+import { OnchainSdkStrategyDataSource } from "./strategy-data-source.js";
 const MAP_LABEL = "pools7DAgo";
 class ApyPlugin extends BasePlugin {
   #apyUrl;
@@ -171,6 +178,69 @@ class ApyPlugin extends BasePlugin {
     }
     return { data, data7DAgo, pointsBase: poolPointsBase, points };
   }
+  /**
+   * Computes a strategy-info snapshot from the current SDK and APY state.
+   *
+   * @throws if plugin is not loaded
+   */
+  getStrategyInfoSnapshot({
+    slippage,
+    quotaReserve,
+    curatorFilter,
+    strategyPayloadsList,
+    showHiddenStrategies
+  }) {
+    if (!this.loaded) {
+      throw new Error("apy plugin not loaded");
+    }
+    const chainId = this.sdk.chainId;
+    const network = this.sdk.networkType;
+    const allowedChains = { [chainId]: network };
+    const source = new OnchainSdkStrategyDataSource(this.sdk);
+    const releasedStrategies = getReleasedStrategiesListCore({
+      strategyPayloadsList,
+      allowedChains,
+      source,
+      curatorFilter,
+      showHiddenStrategies
+    });
+    const cmsOfStrategiesByChain = getStrategyCreditManagersListCore({
+      strategies: releasedStrategies,
+      source,
+      curatorFilter
+    });
+    const { available, disabled, availableList, disabledList } = getAvailableAndDisabledStrategies(
+      releasedStrategies,
+      cmsOfStrategiesByChain,
+      curatorFilter
+    );
+    const apyListByNetwork = {
+      [chainId]: this.apySnapshot.apy
+    };
+    const strategiesInfo = releasedStrategies?.reduce((acc, strategy) => {
+      const info = getStrategyInfoCore({
+        strategy,
+        creditManagers: cmsOfStrategiesByChain?.[strategy.chainId]?.[strategy.id],
+        source,
+        apyListByNetwork,
+        quotaReserve,
+        slippage
+      });
+      if (info) {
+        acc[strategy.chainId] ??= {};
+        acc[strategy.chainId][strategy.id] = info;
+      }
+      return acc;
+    }, {}) ?? {};
+    return {
+      availableStrategies: available,
+      disabledStrategies: disabled,
+      availableList,
+      disabledList,
+      cmsOfStrategiesByChain,
+      strategiesInfo
+    };
+  }
   // ---------------------------------------------------------------------------
   // Plugin lifecycle
   // ---------------------------------------------------------------------------
@@ -202,13 +272,13 @@ class ApyPlugin extends BasePlugin {
   // ---------------------------------------------------------------------------
   async #fetchApy() {
     try {
-      const cache = ApyOutputCache.get(
+      const cache = AxiosCache.get(
         this.#apyUrl,
         this.#cacheTtlMs,
-        this.#logger
+        this.#logger,
+        (data) => `timestamp: ${data.timestamp}`
       );
       const output = await cache.fetch();
-      if (!output) return void 0;
       const chainData = output.chains[this.sdk.chainId];
       if (!chainData) {
         this.#logger?.debug(

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

@@ -1,5 +1,4 @@
 export * from "./ApyPlugin.js";
-export * from "./apy-cache.js";
 export * from "./apy-parser.js";
 export * from "./constants.js";
 export * from "./pool-apy-types.js";

package/dist/esm/plugins/apy/strategy-data-source.js

@@ -0,0 +1,178 @@
+import {
+  ADDRESS_0X0,
+  AP_WETH_TOKEN,
+  NATIVE_ADDRESS,
+  PERCENTAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  RAY
+} from "../../sdk/index.js";
+const lc = (address) => address.toLowerCase();
+class OnchainSdkStrategyDataSource {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  sdk;
+  hasToken(chainId, token) {
+    return !!this.getToken(chainId, token);
+  }
+  getToken(chainId, token) {
+    if (chainId !== this.sdk.chainId) return void 0;
+    const meta = this.sdk.tokensMeta.get(token);
+    if (!meta) return void 0;
+    const address = lc(token);
+    return { address, decimals: meta.decimals, symbol: meta.symbol };
+  }
+  getPool(chainId, pool) {
+    if (chainId !== this.sdk.chainId) return void 0;
+    const market = this.sdk.marketRegister.markets.find(
+      (m) => lc(m.pool.pool.address) === lc(pool)
+    );
+    if (!market) return void 0;
+    const linearModel = market.pool.linearModel;
+    return {
+      address: lc(market.pool.pool.address),
+      totalDebtLimit: market.pool.pool.totalDebtLimit,
+      totalBorrowed: market.pool.pool.totalBorrowed,
+      expectedLiquidity: market.pool.pool.expectedLiquidity,
+      availableLiquidity: market.pool.pool.availableLiquidity,
+      interestModel: {
+        interestModel: market.pool.interestRateModel.address,
+        U_1: BigInt(linearModel.U1),
+        U_2: BigInt(linearModel.U2),
+        R_base: BigInt(linearModel.Rbase),
+        R_slope1: BigInt(linearModel.Rslope1),
+        R_slope2: BigInt(linearModel.Rslope2),
+        R_slope3: BigInt(linearModel.Rslope3),
+        version: Number(linearModel.version),
+        isBorrowingMoreU2Forbidden: linearModel.isBorrowingMoreU2Forbidden
+      }
+    };
+  }
+  getCreditManager(chainId, creditManager) {
+    if (chainId !== this.sdk.chainId) return void 0;
+    try {
+      const found = this.findCreditManager(creditManager);
+      if (!found) return void 0;
+      return this.toCreditManagerView(found.creditSuite, found.market.pool);
+    } catch {
+      return void 0;
+    }
+  }
+  getMarketPrices(chainId, pool) {
+    if (chainId !== this.sdk.chainId) return {};
+    const market = this.sdk.marketRegister.markets.find(
+      (m) => lc(m.pool.pool.address) === lc(pool)
+    );
+    if (!market) return {};
+    const marketPrices = Object.fromEntries(
+      market.priceOracle.mainPrices.entries().map(([token, mainPrice]) => {
+        const tokenLc = lc(token);
+        const reservePrice = market.priceOracle.reservePrices?.get(token);
+        return [tokenLc, mainPrice?.price || reservePrice?.price || 0n];
+      })
+    );
+    const wrappedNativeToken = this.getWrappedNativeToken();
+    const wrappedNativePrice = marketPrices[wrappedNativeToken || ADDRESS_0X0];
+    if (wrappedNativePrice !== void 0) {
+      marketPrices[lc(NATIVE_ADDRESS)] = wrappedNativePrice;
+    }
+    return marketPrices;
+  }
+  getLastSyncTimestamp(chainId) {
+    return chainId === this.sdk.chainId ? Number(this.sdk.timestamp) : void 0;
+  }
+  toCreditManagerView(cs, pool) {
+    const cm = cs.creditManager;
+    const facade = cs.creditFacade;
+    const debtParams = pool.pool.creditManagerDebtParams.get(cm.address);
+    const liquidationThresholds = {};
+    const supportedTokens = {};
+    const forbiddenTokens = {};
+    const quotas = {};
+    for (const [token, q] of pool.pqk.quotas.entries()) {
+      const tokenLc = lc(token);
+      quotas[tokenLc] = {
+        token: tokenLc,
+        rate: BigInt(q.rate) * PERCENTAGE_DECIMALS,
+        quotaIncreaseFee: BigInt(q.quotaIncreaseFee),
+        totalQuoted: q.totalQuoted,
+        limit: q.limit,
+        isActive: q.isActive
+      };
+    }
+    for (const token of cm.collateralTokens) {
+      const tokenLc = lc(token);
+      const lt = cm.liquidationThresholds.get(token);
+      if (lt !== void 0) {
+        liquidationThresholds[tokenLc] = BigInt(lt);
+      }
+      supportedTokens[tokenLc] = true;
+    }
+    const forbiddenMask = facade.forbiddenTokensMask;
+    for (let i = 0; i < cm.collateralTokens.length; i++) {
+      const tokenLc = lc(cm.collateralTokens[i]);
+      if ((forbiddenMask & 1n << BigInt(i)) !== 0n) {
+        forbiddenTokens[tokenLc] = true;
+      }
+    }
+    const baseBorrowRate = debtParams ? Number(
+      pool.pool.baseInterestRate * (BigInt(cm.feeInterest) + PERCENTAGE_FACTOR) * PERCENTAGE_DECIMALS / RAY
+    ) : 0;
+    return {
+      address: lc(cm.address),
+      underlyingToken: lc(cm.underlying),
+      pool: lc(cm.pool),
+      chainId: this.sdk.chainId,
+      baseBorrowRate,
+      feeInterest: cm.feeInterest,
+      availableToBorrow: debtParams?.available ?? 0n,
+      minDebt: facade.minDebt,
+      maxDebt: facade.maxDebt,
+      totalDebt: debtParams?.borrowed ?? 0n,
+      totalDebtLimit: debtParams?.limit ?? 0n,
+      isDegenMode: lc(facade.degenNFT) !== ADDRESS_0X0,
+      degenNFT: lc(facade.degenNFT),
+      liquidationThresholds,
+      quotas,
+      collateralTokens: cm.collateralTokens.map(lc),
+      maxEnabledTokensLength: cm.maxEnabledTokens,
+      version: Number(facade.version),
+      isBorrowingForbidden: facade.maxDebtPerBlockMultiplier === 0,
+      marketConfigurator: lc(cs.marketConfigurator.address),
+      supportedTokens,
+      forbiddenTokens,
+      name: cs.name,
+      isPaused: facade.isPaused,
+      isQuoted: (token) => quotas[token] !== void 0,
+      isForbidden: (token) => forbiddenTokens[token] === true
+    };
+  }
+  findCreditManager(creditManager) {
+    const marketRegister = this.sdk.marketRegister;
+    if (marketRegister.findCreditManager && marketRegister.findByCreditManager) {
+      const creditSuite = marketRegister.findCreditManager(creditManager);
+      const market = marketRegister.findByCreditManager(
+        creditSuite.creditManager.address
+      );
+      return { creditSuite, market };
+    }
+    const cmLc = lc(creditManager);
+    for (const market of marketRegister.markets) {
+      const creditSuite = market.creditManagers.find(
+        (cs) => lc(cs.creditManager.address) === cmLc
+      );
+      if (creditSuite) return { creditSuite, market };
+    }
+    return void 0;
+  }
+  getWrappedNativeToken() {
+    try {
+      return this.sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0)?.toLowerCase();
+    } catch {
+      return void 0;
+    }
+  }
+}
+export {
+  OnchainSdkStrategyDataSource
+};

package/dist/esm/plugins/delayed-withdrawal/DelayedWithdrawalPlugin.js

@@ -1,4 +1,5 @@
 import { iWithdrawalCompressorV310Abi } from "../../abi/IWithdrawalCompressorV310.js";
+import { iWithdrawalCompressorV311Abi } from "../../abi/IWithdrawalCompressorV311.js";
 import {
   AddressMap,
   BasePlugin,
@@ -19,8 +20,8 @@ class DelayedWithdrawalPlugin extends BasePlugin {
     const resp = await this.client.multicall({
       contracts: compressor ? creditManagers.map(
         (cm) => ({
-          abi: iWithdrawalCompressorV310Abi,
-          address: compressor,
+          address: compressor.address,
+          abi: compressor.version === 310 ? iWithdrawalCompressorV310Abi : iWithdrawalCompressorV311Abi,
           functionName: "getWithdrawableAssets",
           args: [cm.creditManager.address]
         })

package/dist/esm/plugins/remote-configs/CustomConfigSource.js

@@ -0,0 +1,17 @@
+class CustomConfigSource {
+  #getPools;
+  #getStrategies;
+  constructor(options) {
+    this.#getPools = options.getPools;
+    this.#getStrategies = options.getStrategies;
+  }
+  async getPools() {
+    return this.#getPools();
+  }
+  async getStrategies() {
+    return this.#getStrategies();
+  }
+}
+export {
+  CustomConfigSource
+};

package/dist/esm/plugins/remote-configs/RemoteConfigSource.js

@@ -0,0 +1,32 @@
+import { AxiosCache } from "../../common-utils/axios-cache/index.js";
+const DEFAULT_POOLS_URL = "https://static.gearbox.finance/client-v3/configs/pools/pools.json";
+const DEFAULT_STRATEGIES_URL = "https://static.gearbox.finance/client-v3/configs/strategies/strategies.json";
+const DEFAULT_CACHE_TTL_MS = 30 * 60 * 1e3;
+class RemoteConfigSource {
+  #poolsCache;
+  #strategiesCache;
+  constructor(options) {
+    const poolsUrl = options?.poolsUrl ?? DEFAULT_POOLS_URL;
+    const strategiesUrl = options?.strategiesUrl ?? DEFAULT_STRATEGIES_URL;
+    const ttlMs = options?.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    this.#poolsCache = AxiosCache.get(
+      poolsUrl,
+      ttlMs,
+      options?.logger
+    );
+    this.#strategiesCache = AxiosCache.get(
+      strategiesUrl,
+      ttlMs,
+      options?.logger
+    );
+  }
+  async getPools() {
+    return this.#poolsCache.fetch();
+  }
+  async getStrategies() {
+    return this.#strategiesCache.fetch();
+  }
+}
+export {
+  RemoteConfigSource
+};

package/dist/esm/plugins/remote-configs/RemoteConfigsPlugin.js

@@ -0,0 +1,165 @@
+import { isAddress } from "viem";
+import {
+  BasePlugin,
+  TypedObjectUtils
+} from "../../sdk/index.js";
+import { RemoteConfigSource } from "./RemoteConfigSource.js";
+class RemoteConfigsPlugin extends BasePlugin {
+  #sources;
+  #pools;
+  #strategies;
+  constructor(loadOnAttach = false, options) {
+    super(loadOnAttach);
+    this.#sources = options?.sources ?? [new RemoteConfigSource()];
+  }
+  get loaded() {
+    return !!this.#pools && !!this.#strategies;
+  }
+  async load(force) {
+    if (!force && this.loaded) {
+      return this.state;
+    }
+    const [pools, strategies] = await Promise.all([
+      this.#loadPools(),
+      this.#loadStrategies()
+    ]);
+    this.#pools = pools;
+    this.#strategies = strategies;
+    return this.state;
+  }
+  async syncState() {
+    await this.load(false);
+  }
+  get state() {
+    return {
+      pools: this.pools,
+      strategies: this.strategies
+    };
+  }
+  hydrate(state) {
+    this.#pools = state.pools;
+    this.#strategies = state.strategies;
+  }
+  stateHuman(_) {
+    return this.state;
+  }
+  // ---------------------------------------------------------------------------
+  // Accessors
+  // ---------------------------------------------------------------------------
+  /**
+   * Pool configs for the current SDK network.
+   * @throws if plugin is not loaded
+   */
+  get pools() {
+    if (!this.#pools) {
+      throw new Error("remote-configs plugin not loaded");
+    }
+    return this.#pools;
+  }
+  /**
+   * Strategy configs for the current SDK network.
+   * @throws if plugin is not loaded
+   */
+  get strategies() {
+    if (!this.#strategies) {
+      throw new Error("remote-configs plugin not loaded");
+    }
+    return this.#strategies;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  async #loadPools() {
+    for (const source of this.#sources) {
+      try {
+        const data = await source.getPools();
+        const mapped = this.#mapPoolPayload(
+          data.filter(
+            (p) => p.chainId === this.sdk.chainId && p.network.toLowerCase() === this.sdk.networkType.toLowerCase()
+          )
+        );
+        return mapped;
+      } catch (e) {
+        this.logger?.warn(e, `${source.constructor.name} failed to load pools`);
+      }
+    }
+    throw new Error("all config sources failed to load pools");
+  }
+  async #loadStrategies() {
+    for (const source of this.#sources) {
+      try {
+        const data = await source.getStrategies();
+        const mapped = this.#mapStrategyPayload(
+          data.filter(
+            (s) => s.chainId === this.sdk.chainId && s.network.toLowerCase() === this.sdk.networkType.toLowerCase()
+          )
+        );
+        return mapped;
+      } catch (e) {
+        this.logger?.warn(
+          e,
+          `${source.constructor.name} failed to load strategies`
+        );
+      }
+    }
+    throw new Error("all config sources failed to load strategies");
+  }
+  #mapPoolPayload(payload) {
+    return payload.reduce((acc, p) => {
+      const addressLc = p.address.toLowerCase();
+      if (isAddress(addressLc)) {
+        acc.push({
+          ...p,
+          address: addressLc
+        });
+      }
+      return acc;
+    }, []);
+  }
+  #mapStrategyPayload(payload) {
+    return payload.reduce((acc, p) => {
+      const tokenOutAddressLc = p.tokenOutAddress.toLowerCase();
+      const creditManagers = p.creditManagers.filter((cm) => isAddress(cm)).map((cm) => cm.toLowerCase());
+      const zeroSlippage = p.zeroSlippage ? TypedObjectUtils.entries(p.zeroSlippage).reduce((zsAcc, [address, value]) => {
+        const addressLc = address.toLowerCase();
+        if (isAddress(addressLc)) zsAcc[addressLc] = value;
+        return zsAcc;
+      }, {}) : void 0;
+      const additionalRewardQuotas = p.additionalRewardQuotas ? TypedObjectUtils.entries(p.additionalRewardQuotas).reduce((rqAcc, [address, value]) => {
+        const addressLc = address.toLowerCase();
+        if (isAddress(addressLc)) {
+          const rewards = value?.filter((r) => isAddress(r)).map((r) => r.toLowerCase());
+          rqAcc[addressLc] = rewards;
+        }
+        return rqAcc;
+      }, {}) : void 0;
+      const additionalCollaterals = p.additionalCollaterals?.reduce((colAcc, cfg) => {
+        const token = typeof cfg === "string" ? cfg : cfg.token;
+        const tokenLc = token.toLowerCase();
+        const valid = isAddress(tokenLc);
+        if (valid && !colAcc[tokenLc]) colAcc[tokenLc] = [];
+        const nextCfg = typeof cfg === "string" ? tokenLc : {
+          token: tokenLc,
+          cm: cfg.cm.toLowerCase()
+        };
+        if (valid) colAcc[tokenLc].push(nextCfg);
+        return colAcc;
+      }, {});
+      if (isAddress(tokenOutAddressLc)) {
+        const { additionalCollaterals: _, ...rest } = p;
+        acc.push({
+          ...rest,
+          tokenOutAddress: tokenOutAddressLc,
+          creditManagers,
+          ...zeroSlippage ? { zeroSlippage } : {},
+          ...additionalRewardQuotas ? { additionalRewardQuotas } : {},
+          ...additionalCollaterals ? { additionalCollaterals } : {}
+        });
+      }
+      return acc;
+    }, []);
+  }
+}
+export {
+  RemoteConfigsPlugin
+};

package/dist/esm/plugins/remote-configs/index.js

@@ -0,0 +1,4 @@
+export * from "./CustomConfigSource.js";
+export * from "./RemoteConfigSource.js";
+export * from "./RemoteConfigsPlugin.js";
+export * from "./types.js";

package/dist/esm/plugins/remote-configs/package.json

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

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

@@ -11,7 +11,8 @@ class RewardAmountAPI {
     pools,
     account,
     network,
-    reportError
+    reportError,
+    apiKey
   }) {
     const [merkleXYZLMResponse] = await Promise.allSettled([
       MerkleXYZApi.fetchWithFallback(
@@ -20,7 +21,8 @@ class RewardAmountAPI {
             chainId: chains[network].id,
             user: getAddress(account)
           }
-        })
+        }),
+        apiKey
       )
     ]);
     const merkleXYZLm = RewardAmountAPI.extractFulfilled(

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

@@ -4,11 +4,17 @@ class MerkleXYZApi {
   }
   static defaultDomain = "https://api.merkl.xyz";
   static angleDomain = "https://api-merkl.angle.money";
-  static fetchWithFallback = async (getUrl) => {
+  static apiKeyHeader = "X-API-Key";
+  static fetchWithFallback = async (getUrl, apiKey) => {
+    const headers = apiKey ? { [MerkleXYZApi.apiKeyHeader]: apiKey } : void 0;
     try {
-      return await axios.get(getUrl(MerkleXYZApi.defaultDomain));
+      return await axios.get(getUrl(MerkleXYZApi.defaultDomain), {
+        headers
+      });
     } catch {
-      return await axios.get(getUrl(MerkleXYZApi.angleDomain));
+      return await axios.get(getUrl(MerkleXYZApi.angleDomain), {
+        headers
+      });
     }
   };
   static getUserRewardsUrl = (options) => (domain) => `${domain}/v4/users/${options.params.user}/rewards?chainId=${options.params.chainId}`;