@merkl/api 0.10.240 → 0.10.242

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) {

package/dist/src/libs/tokens/balances.d.ts

@@ -6,6 +6,6 @@ type ReturnType = {
         decimals: number;
     };
 };
-export declare function getOnlyUserBalance(chainId: number, userAddress: string, tokenAddresses: string[]): Promise<UncachedResult<ReturnType>>;
+export declare function getOnlyUserBalance(chainId: number, userAddress: string, tokenAddresses: string[]): Promise<ReturnType>;
 export declare function getUserBalances(user: string, chainId: number, tokenAddresses?: string[]): Promise<UncachedResult<ReturnType>>;
 export {};

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

@@ -1,42 +1,43 @@
-import { Erc20__factory } 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) {
-        calls.push({
-            allowFailure: true,
-            callData: ERC20_Interface.encodeFunctionData("balanceOf", [userAddress]),
-            target: tokenAddress,
-        });
+        if (chainId === ChainId.ZKSYNC && tokenAddress === ETH_ZKSYNC_ADDRESS) {
+            calls.push({
+                allowFailure: true,
+                callData: EthOnZKSync_INTERFACE.encodeFunctionData("balanceOf", [userAddress]),
+                target: tokenAddress,
+            });
+        }
+        else {
+            calls.push({
+                allowFailure: true,
+                callData: ERC20_Interface.encodeFunctionData("balanceOf", [userAddress]),
+                target: tokenAddress,
+            });
+        }
     }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                const res = {};
-                for (let j = 0; j < tokenAddresses.length; j++) {
-                    const tokenAddress = tokenAddresses[j];
-                    let balance = "0";
-                    try {
-                        balance = ERC20_Interface.decodeFunctionResult("balanceOf", result[j])[0]?.toString();
-                    }
-                    catch (_error) {
-                        log.local(`❌ Failed to call balanceOf for ${tokenAddress} on ${chainId}`);
-                    }
-                    res[tokenAddress] = {
-                        balance: balance,
-                        decimals: 0,
-                        symbol: "",
-                    };
-                }
-                return res;
-            },
-        },
-    };
+    const result = await ChainInteractionService(chainId).fetchState(calls);
+    const res = {};
+    for (let j = 0; j < tokenAddresses.length; j++) {
+        const tokenAddress = tokenAddresses[j];
+        let balance = "0";
+        try {
+            balance = ERC20_Interface.decodeFunctionResult("balanceOf", result[j].returnData)[0]?.toString();
+        }
+        catch (_error) {
+            log.local(`❌ Failed to call balanceOf for ${tokenAddress} on ${NETWORK_LABELS[chainId]}`);
+        }
+        res[tokenAddress] = {
+            balance: balance,
+            decimals: 0,
+            symbol: "",
+        };
+    }
+    return res;
 }
 export async function getUserBalances(user, chainId, tokenAddresses) {
     const tokens = (await getTokensListWithCache())?.[chainId];
@@ -53,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/modules/v4/token/token.service.js

@@ -1,6 +1,5 @@
 import { getTokensListWithCache } from "../../../libs/getTokensList";
 import { getOnlyUserBalance } from "../../../libs/tokens/balances";
-import { executeSimple } from "../../../utils/execute";
 import { log } from "../../../utils/logger";
 import { apiDbClient } from "../../../utils/prisma";
 import { Prisma } from "../../../../database/api/.generated";
@@ -22,7 +21,7 @@ export class TokenService {
      * Fetches balances of provided tokens
      */
     static async fetchBalances(chainId, userAddress, tokens) {
-        const balances = await executeSimple(chainId, getOnlyUserBalance(chainId, userAddress, tokens.map(t => t.address)));
+        const balances = await getOnlyUserBalance(chainId, userAddress, tokens.map(t => t.address));
         const tokensWithBalances = tokens.map(t => {
             const balance = balances[t.address] ??
                 balances[Object.keys(balances).find(a => a?.toLowerCase() === t.address?.toLowerCase()) ?? ""];

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") {