@merkl/api 0.10.241 → 0.10.243

package/dist/src/libs/campaigns/utils/getEulerV2Vaults.js

@@ -9,12 +9,14 @@ import { safeFetchLogs } from "./fetchLogs";
 const VAULT_LENS_ADDRESS = {
     [ChainId.MAINNET]: "0x57904B4DF131F00DEE9BB75a8FA1D27744035c90",
     [ChainId.SWELL]: "0x7caA3c60D730D94D4b5E0E80E3b7D461fD153526",
+    [ChainId.BASE]: "0xc20B6e1d52ce377a450512958EEE8142063436CD",
 };
 const EVC_CREATION_BLOCK = {
     [ChainId.MAINNET]: 20529207,
     [ChainId.SWELL]: 485320,
+    [ChainId.BASE]: 24127584,
 };
-const eulerChainds = [ChainId.MAINNET, ChainId.SWELL];
+const eulerChainds = [ChainId.MAINNET, ChainId.SWELL, ChainId.BASE];
 async function getEulerV2Vaults() {
     let vaults = [];
     for (const chainId of eulerChainds) {
@@ -42,7 +44,7 @@ async function getEulerV2Vaults() {
                     return {
                         allowFailure: true,
                         callData: EulerVaultLensInterface.encodeFunctionData("getRecognizedCollateralsLTVInfo", [vault.address]),
-                        target: VAULT_LENS_ADDRESS[ChainId.MAINNET],
+                        target: VAULT_LENS_ADDRESS[chainId],
                     };
                 }),
             });
@@ -62,7 +64,7 @@ async function getEulerV2Vaults() {
                     });
                 }
             }
-            const resCollatUnderlying = await batchMulticallCallWithRetry(ChainId.MAINNET, {
+            const resCollatUnderlying = await batchMulticallCallWithRetry(chainId, {
                 calls: callsCollatUnderlying,
             });
             for (let i = 0; i < resCollatUnderlying.length; i = i + 2) {
@@ -73,7 +75,7 @@ async function getEulerV2Vaults() {
                     target: underlyingToken,
                 });
             }
-            const resCollatUnderlyingSymbol = await batchMulticallCallWithRetry(ChainId.MAINNET, {
+            const resCollatUnderlyingSymbol = await batchMulticallCallWithRetry(chainId, {
                 calls: callsCollatUnderlyingSymbol,
             });
             vaults = vaults.concat((await Promise.all(decodedVaults.map(async (decodedVault, index) => {

package/dist/src/libs/tokens/balances.js

@@ -1,11 +1,11 @@
-import { ChainId, ChainInteractionService, Erc20__factory, EthOnZKSync_INTERFACE, NETWORK_LABELS, } from "@sdk";
+import { ChainId, ChainInteractionService, ETH_ADDRESS, ETH_ZKSYNC_ADDRESS, Erc20__factory, EthOnZKSync_INTERFACE, NETWORK_LABELS, } from "@sdk";
 import { log } from "../../utils/logger";
 import { getTokensListWithCache } from "../getTokensList";
 export async function getOnlyUserBalance(chainId, userAddress, tokenAddresses) {
     const calls = [];
     const ERC20_Interface = Erc20__factory.createInterface();
     for (const tokenAddress of tokenAddresses) {
-        if (chainId === ChainId.ZKSYNC && tokenAddress === "0x000000000000000000000000000000000000800A") {
+        if (chainId === ChainId.ZKSYNC && tokenAddress === ETH_ZKSYNC_ADDRESS) {
             calls.push({
                 allowFailure: true,
                 callData: EthOnZKSync_INTERFACE.encodeFunctionData("balanceOf", [userAddress]),
@@ -54,7 +54,7 @@ export async function getUserBalances(user, chainId, tokenAddresses) {
             },
         };
     }
-    const tokenListAddresses = Object.keys(tokens).filter(t => t !== "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE");
+    const tokenListAddresses = Object.keys(tokens).filter(t => t !== ETH_ADDRESS);
     const ERC20_Interface = Erc20__factory.createInterface();
     const calls = [];
     for (const tokenAddress of tokenListAddresses) {

package/dist/src/modules/v4/interaction/interaction.service.js

@@ -1,3 +1,4 @@
+import { ETH_ZKSYNC_ADDRESS } from "@sdk";
 import { decodeFunctionResult, encodeFunctionData, parseAbi } from "viem";
 import { ChainInteractionService } from "../chainInteraction";
 import { EnsoService } from "../enso/enso.service";
@@ -61,6 +62,9 @@ export class InteractionService {
      * @returns approved?, approval tx & allowance amount
      */
     static async getApproval(chainId, owner, spender, tokenAddress, amount) {
+        // Normalizing ETH on ZKSync
+        if (tokenAddress === ETH_ZKSYNC_ADDRESS)
+            tokenAddress = ETH_ZKSYNC_ADDRESS;
         //TODO: add utils to make using viem type-safety more concise
         const abi = parseAbi([
             "function approve(address, uint256) returns (bool)",
@@ -95,6 +99,9 @@ export class InteractionService {
         };
     }
     static async getTransaction(provider, chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, slippage) {
+        // Normalizing ETH on ZKSync
+        if (fromTokenAddress === ETH_ZKSYNC_ADDRESS)
+            fromTokenAddress = ETH_ZKSYNC_ADDRESS;
         if (provider === "zap")
             return await KyberZapService.getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, slippage);
         const { tx, ...quote } = await EnsoService.getTransaction({

package/dist/src/routes/v1/allowances.js

@@ -3,13 +3,13 @@ import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
 import { getUserBalances } from "../../libs/tokens/balances";
 import { executeSimple } from "../../utils/execute";
 import { throwOnInvalidAddress } from "../../utils/throw";
-import { ChainId, ERC20Interface, registry } from "@sdk";
+import { ChainId, ERC20Interface, ETH_ADDRESS, registry } from "@sdk";
 import { t } from "elysia";
 export async function getUserAllowances(user, spenders, tokens, chainId, additionalTokenAddresses) {
     /** Filtered tokens list */
     const filteredTokens = Object.keys(tokens).reduce((filteredTokensList, tokenAddress) => {
         if (tokenAddress === "0x0000000000000000000000000000000000001010" ||
-            tokenAddress === "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE" ||
+            tokenAddress === ETH_ADDRESS ||
             tokenAddress === registry(ChainId.MAINNET)?.veANGLE)
             return filteredTokensList;
         if (!tokens[tokenAddress]?.wrappingMethod || tokens[tokenAddress]?.wrappingMethod !== "Convex") {