@merkl/api 0.10.240 → 0.10.241

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, 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 === "0x000000000000000000000000000000000000800A") {
+            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];

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()) ?? ""];