@merkl/api 0.21.47 → 1.0.0

package/dist/src/libs/positions/prepareFetch.js

@@ -1,392 +0,0 @@
-// @ts-nocheck
-import { VEST_TOKEN } from "@/engine/deprecated/dynamicData/implementations/Vest";
-import { Campaign, Forwarder, MorphoSubCampaignType, } from "@sdk";
-import { utils } from "ethers";
-function prepareClammFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.CLAMM) {
-        return previous;
-    }
-    const amm = campaign.campaignParameters.amm;
-    // if (Object.values(PriorityAMM?.[campaign.chainId as any] ?? {}).includes(amm)) amm = AMM.UniswapV3;
-    if (!previous[amm]) {
-        previous[amm] = {};
-    }
-    if (!previous[amm][campaign.campaignParameters.poolAddress]) {
-        const forwarders = {};
-        if (campaign.forwarders && campaign.forwarders.length > 0) {
-            for (const forwarder of campaign.forwarders) {
-                forwarders[utils.getAddress(forwarder.almAddress)] = forwarder;
-            }
-        }
-        previous[amm][campaign.campaignParameters.poolAddress] = {
-            token0: campaign.campaignParameters.token0,
-            token1: campaign.campaignParameters.token1,
-            symbolToken0: campaign.campaignParameters.symbolToken0,
-            symbolToken1: campaign.campaignParameters.symbolToken1,
-            decimalsToken0: campaign.campaignParameters.decimalsToken0,
-            decimalsToken1: campaign.campaignParameters.decimalsToken1,
-            forwarders: forwarders,
-            poolBalanceToken0: campaign.poolBalanceToken0,
-            poolBalanceToken1: campaign.poolBalanceToken1,
-            poolTotalLiquidity: campaign.poolTotalLiquidity,
-            campaigns: {},
-        };
-    }
-    else {
-        const forwarders = previous[amm][campaign.campaignParameters.poolAddress].forwarders;
-        if (campaign.forwarders && campaign.forwarders.length > 0) {
-            for (const forwarder of campaign.forwarders) {
-                if (!forwarders[utils.getAddress(forwarder.almAddress)]) {
-                    forwarders[utils.getAddress(forwarder.almAddress)] = forwarder;
-                }
-            }
-        }
-        previous[amm][campaign.campaignParameters.poolAddress].forwarders = forwarders;
-    }
-    previous[amm][campaign.campaignParameters.poolAddress].campaigns[campaign.campaignId] = {
-        whitelist: campaign.campaignParameters.whitelist,
-        blacklist: campaign.campaignParameters.blacklist,
-        rewardToken: campaign.rewardToken,
-        decimalsRewardToken: campaign.campaignParameters.decimalsRewardToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        startTimestamp: campaign.startTimestamp,
-        endTimestamp: campaign.endTimestamp,
-        isOutOfRangeIncentivized: campaign.campaignParameters.isOutOfRangeIncentivized,
-        blacklistedLiquidity: campaign.blacklistedLiquidity,
-        blacklistedBalance0: campaign.blacklistedBalance0,
-        blacklistedBalance1: campaign.blacklistedBalance1,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-        propToken0: campaign.campaignParameters.weightToken0 / 1e5,
-        propToken1: campaign.campaignParameters.weightToken1 / 1e5,
-        propFees: campaign.campaignParameters.weightFees / 1e5,
-        mainParameter: campaign.mainParameter,
-    };
-    return previous;
-}
-function prepareERC20Fetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.ERC20) {
-        return previous;
-    }
-    if (!previous[campaign.campaignParameters.targetToken]) {
-        previous[campaign.campaignParameters.targetToken] = {
-            decimals: campaign.campaignParameters.decimalsTargetToken,
-            totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-            priceTargetToken: !!campaign.typeInfo?.priceTargetToken ? campaign.typeInfo.priceTargetToken : 0,
-            campaigns: {},
-        };
-    }
-    previous[campaign.campaignParameters.targetToken].campaigns[campaign.campaignId] = {
-        rewardToken: campaign.rewardToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-    };
-    return previous;
-}
-function prepareDolomiteFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.DOLOMITE) {
-        return previous;
-    }
-    if (!previous[campaign.mainParameter]) {
-        previous[campaign.mainParameter] = {
-            symbol: campaign.campaignParameters.symbolTargetToken,
-            decimals: campaign.campaignParameters.decimalsTargetToken,
-            targetToken: campaign.campaignParameters.targetToken,
-            totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-            subCampaignType: campaign.campaignParameters.subCampaignType,
-            marketIndex: campaign.campaignParameters.marketIndex,
-            campaigns: {},
-        };
-    }
-    previous[campaign.mainParameter].campaigns[campaign.campaignId] = {
-        rewardToken: campaign.rewardToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-    };
-    return previous;
-}
-/**
- * Silo
- */
-function addForwarderToSiloCampaign(previousForwarder, // TODO @BaptistG typings
-newForward) {
-    if (!previousForwarder[newForward.sender]) {
-        previousForwarder[newForward.sender] = [];
-    }
-    if (newForward.forwarderType === Forwarder.ERC20) {
-        if (!previousForwarder[newForward.sender].includes(newForward.token)) {
-            previousForwarder[newForward.sender].push(newForward.token);
-        }
-    }
-    return previousForwarder;
-}
-function prepareSiloFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.SILO) {
-        return previous;
-    }
-    if (!previous["allForwarders"]) {
-        previous["allForwarders"] = {};
-        previous["mainParameters"] = {};
-    }
-    if (!previous["mainParameters"][campaign.mainParameter]) {
-        previous["mainParameters"][campaign.mainParameter] = {
-            token: campaign.campaignParameters.targetToken,
-            decimals: campaign.campaignParameters.decimalsTargetToken,
-            symbol: campaign.campaignParameters.symbolTargetToken,
-            priceTargetToken: !!campaign.totalSupplyTargetToken && !!campaign.tvl ? campaign.tvl / campaign.totalSupplyTargetToken : 0,
-            campaigns: {},
-            allForwarders: {},
-        };
-    }
-    const forwarders = {};
-    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
-        for (const forwarder of campaign.campaignParameters.forwarders) {
-            if (campaign.campaignParameters.whitelist.length === 0 && campaign.campaignParameters.blacklist.length === 0) {
-                forwarders[utils.getAddress(forwarder.sender)] = forwarder;
-                previous["allForwarders"] = addForwarderToSiloCampaign(previous["allForwarders"], forwarder);
-                previous["mainParameters"][campaign.mainParameter].allForwarders = addForwarderToSiloCampaign(previous["mainParameters"][campaign.mainParameter].allForwarders, forwarder);
-            }
-            else if (campaign.campaignParameters.whitelist.length > 0) {
-                if (campaign.campaignParameters.whitelist.includes(utils.getAddress(forwarder.sender))) {
-                    forwarders[utils.getAddress(forwarder.sender)] = forwarder;
-                    previous["allForwarders"] = addForwarderToSiloCampaign(previous["allForwarders"], forwarder);
-                    previous["mainParameters"][campaign.mainParameter].allForwarders = addForwarderToSiloCampaign(previous["mainParameters"][campaign.mainParameter].allForwarders, forwarder);
-                }
-            }
-            else if (campaign.campaignParameters.blacklist.length > 0) {
-                if (!campaign.campaignParameters.blacklist.includes(utils.getAddress(forwarder.sender))) {
-                    forwarders[utils.getAddress(forwarder.sender)] = forwarder;
-                    previous["allForwarders"] = addForwarderToSiloCampaign(previous["allForwarders"], forwarder);
-                    previous["mainParameters"][campaign.mainParameter].allForwarders = addForwarderToSiloCampaign(previous["mainParameters"][campaign.mainParameter].allForwarders, forwarder);
-                }
-            }
-        }
-    }
-    previous["mainParameters"][campaign.mainParameter].campaigns[campaign.campaignId] = {
-        rewardToken: campaign.rewardToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-        forwarders: forwarders,
-    };
-    return previous;
-}
-/**
- * Morpho
- */
-function prepareMorphoFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.MORPHO) {
-        return previous;
-    }
-    if (campaign.campaignSubType === MorphoSubCampaignType.META) {
-        previous[campaign.mainParameter] = {
-            rewardToken: campaign.rewardToken,
-            targetToken: campaign.campaignParameters.targetToken,
-            symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-            subtype: campaign.campaignSubType,
-            tvl: campaign.tvl,
-            marketId: campaign.campaignParameters.marketId,
-            decimals: campaign.campaignParameters.decimalsTargetToken,
-            totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-            amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-            forwarders: {},
-        };
-    }
-    const forwarders = {};
-    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
-        for (const forwarder of campaign.campaignParameters.forwarders) {
-            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
-        }
-    }
-    previous[campaign.mainParameter] = {
-        rewardToken: campaign.rewardToken,
-        targetToken: campaign.campaignParameters.targetToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        subtype: campaign.campaignSubType,
-        tvl: campaign.tvl,
-        marketId: campaign.campaignParameters.marketId,
-        forwarders: forwarders,
-        decimals: campaign.campaignParameters.decimalsTargetToken,
-        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-    };
-    return previous;
-}
-/**
- * Badger
- */
-function prepareBadgerFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.BADGER) {
-        return previous;
-    }
-    const forwarders = {};
-    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
-        for (const forwarder of campaign.campaignParameters.forwarders) {
-            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
-        }
-    }
-    previous[campaign.mainParameter] = {
-        rewardToken: campaign.rewardToken,
-        targetToken: campaign.campaignParameters.targetToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        subtype: campaign.campaignSubType,
-        tvl: campaign.tvl,
-        forwarders: forwarders,
-        decimals: campaign.campaignParameters.decimalsTargetToken,
-        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-    };
-    return previous;
-}
-/**
- * Ajna
- */
-function prepareAjnaFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.AJNA) {
-        return previous;
-    }
-    const forwarders = {};
-    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
-        for (const forwarder of campaign.campaignParameters.forwarders) {
-            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
-        }
-    }
-    previous[campaign.mainParameter] = {
-        rewardToken: campaign.rewardToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        subtype: campaign.campaignSubType,
-        tvl: campaign.tvl,
-        forwarders: forwarders,
-        quoteToken: campaign.campaignParameters.quoteToken,
-        poolId: campaign.campaignParameters.poolId,
-        decimalsQuoteToken: campaign.campaignParameters.decimalsQuoteToken,
-        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-        computedtotalSupply: campaign.computedtotalSupply,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-    };
-    return previous;
-}
-/**
- * Euler
- */
-function prepareEulerFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.EULER) {
-        return previous;
-    }
-    if (!previous[campaign.campaignParameters.targetToken]) {
-        previous[campaign.campaignParameters.targetToken] = {
-            decimals: campaign.campaignParameters.decimalsTargetToken,
-            totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-            priceTargetToken: !!campaign.typeInfo?.priceTargetToken ? campaign.typeInfo.priceTargetToken : 0,
-            campaigns: {},
-        };
-    }
-    previous[campaign.campaignParameters.targetToken].campaigns[campaign.campaignId] = {
-        rewardToken: campaign.rewardToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-    };
-    return previous;
-}
-function prepareCompoundFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.COMPOUND) {
-        return previous;
-    }
-    const forwarders = {};
-    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
-        for (const forwarder of campaign.campaignParameters.forwarders) {
-            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
-        }
-    }
-    previous[campaign.mainParameter] = {
-        rewardToken: campaign.rewardToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        subtype: campaign.campaignSubType,
-        compFork: campaign.campaignParameters.compFork,
-        tvl: campaign.tvl,
-        forwarders: forwarders,
-        targetToken: campaign.campaignParameters.targetToken,
-        decimalsTargetToken: campaign.campaignParameters.decimalsTargetToken,
-        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-        underlyingToken: campaign.campaignParameters.underlyingToken,
-        symbolUnderlyingToken: campaign.campaignParameters.symbolUnderlyingToken,
-        decimalsUnderlyingToken: campaign.campaignParameters.decimalsUnderlyingToken,
-        symbolTargetToken: campaign.campaignParameters.symbolTargetToken,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-    };
-    return previous;
-}
-function prepareEigenLayerFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.EIGENLAYER) {
-        return previous;
-    }
-    const forwarders = {};
-    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
-        for (const forwarder of campaign.campaignParameters.forwarders) {
-            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
-        }
-    }
-    previous[campaign.mainParameter] = {
-        rewardToken: campaign.rewardToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        tvl: campaign.tvl,
-        forwarders: forwarders,
-        targetToken: campaign.campaignParameters.strategy,
-        decimalsTargetToken: campaign.campaignParameters.decimalsUnderlyingToken,
-        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-        underlyingToken: campaign.campaignParameters.underlyingToken,
-        symbolUnderlyingToken: campaign.campaignParameters.symbolUnderlyingToken,
-        decimals: campaign.campaignParameters.decimalsUnderlyingToken,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-    };
-    return previous;
-}
-function prepareVestFetch(previous, campaign) {
-    if (campaign.campaignType !== Campaign.VEST) {
-        return previous;
-    }
-    const forwarders = {};
-    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
-        for (const forwarder of campaign.campaignParameters.forwarders) {
-            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
-        }
-    }
-    previous[campaign.mainParameter] = {
-        rewardToken: campaign.rewardToken,
-        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
-        tvl: campaign.tvl,
-        forwarders: forwarders,
-        targetToken: VEST_TOKEN,
-        decimalsTargetToken: 6,
-        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
-        decimals: 6,
-        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
-    };
-    return previous;
-}
-export function prepareFetch(type, previous, // FIXME
-campaign //FIXME
-) {
-    switch (type) {
-        case Campaign.CLAMM:
-            return prepareClammFetch(previous, campaign);
-        case Campaign.ERC20:
-            return prepareERC20Fetch(previous, campaign);
-        case Campaign.SILO:
-            return prepareSiloFetch(previous, campaign);
-        case Campaign.DOLOMITE:
-            return prepareDolomiteFetch(previous, campaign);
-        case Campaign.MORPHO:
-            return prepareMorphoFetch(previous, campaign);
-        case Campaign.BADGER:
-            return prepareBadgerFetch(previous, campaign);
-        case Campaign.EULER:
-            return prepareEulerFetch(previous, campaign);
-        case Campaign.AJNA:
-            return prepareAjnaFetch(previous, campaign);
-        case Campaign.COMPOUND:
-            return prepareCompoundFetch(previous, campaign);
-        case Campaign.EIGENLAYER:
-            return prepareEigenLayerFetch(previous, campaign);
-        default:
-            return previous;
-    }
-}

package/dist/src/libs/positions/silo/index.js

@@ -1,68 +0,0 @@
-// @ts-nocheck
-import { BN2Number, ERC20Interface } from "@sdk";
-import { getAddress } from "ethers/lib/utils";
-export async function getSiloUserPositions(user, _chainId, mainParameters) {
-    /**
-     * Fetch user positions
-     */
-    const sendTokenMapping = {};
-    const calls = [];
-    let i = 0;
-    for (const [sender, tokens] of Object.entries(mainParameters.allForwarders)) {
-        for (const token of tokens) {
-            if (!sendTokenMapping[`${sender}_${token}`] && !(sendTokenMapping[`${sender}_${token}`] === 0)) {
-                calls.push({
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
-                    target: token,
-                });
-                calls.push({
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: token,
-                });
-                sendTokenMapping[`${sender}_${token}`] = i;
-                i++;
-            }
-        }
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                const finalRes = {};
-                for (const mainParameter of Object.keys(mainParameters.mainParameters)) {
-                    const res = {
-                        userPositions: [],
-                        symbol: mainParameters.mainParameters[mainParameter].symbol,
-                        decimals: mainParameters.mainParameters[mainParameter].decimals,
-                        token: mainParameters.mainParameters[mainParameter].token,
-                        userTVL: 0,
-                    };
-                    for (const [sender, tokens] of Object.entries(mainParameters.mainParameters[mainParameter].allForwarders)) {
-                        for (const token of tokens) {
-                            // Direct Positions
-                            const balance = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[2 * sendTokenMapping[`${sender}_${token}`]])[0]);
-                            if (balance > 0) {
-                                res.userPositions.push({
-                                    balance: balance,
-                                    token: getAddress(token),
-                                    origin: "Direct",
-                                    totalSupply: BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[1 + 2 * sendTokenMapping[`${sender}_${token}`]])[0], res.decimals),
-                                    tvl: mainParameters.mainParameters[mainParameter].priceTargetToken * balance,
-                                });
-                                res.userTVL += mainParameters.mainParameters[mainParameter].priceTargetToken * balance;
-                            }
-                        }
-                    }
-                    if (res.userPositions.length > 0) {
-                        finalRes[`5_${mainParameter}`] = { ...res };
-                    }
-                }
-                return finalRes;
-            },
-        },
-    };
-}

package/dist/src/libs/positions/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/libs/staticCampaigns.js

@@ -1,15 +0,0 @@
-import { Redis } from "@/cache";
-import { engineDbClient } from "@db";
-async function staticCampaigns(chainId) {
-    return await engineDbClient.campaigns.findMany({
-        where: {
-            chainId: chainId,
-        },
-    });
-}
-/**
- * @deprecated - to remove once:
- *  - old update page is deprecated
- *  - v3 campaigns route is removed
- */
-export const staticCampaignWithCache = async (chainId) => await Redis.getOrSet(`StaticCampaigns_${chainId}`, staticCampaigns, chainId);

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

@@ -1,18 +0,0 @@
-import { ChainId, ChainInteractionService, ETH_ZKSYNC_ADDRESS, Erc20__factory, EthOnZKSync_INTERFACE } from "@sdk";
-export async function getUserAllowance(chainId, tokenAddress, userAddress, spenderAddresses) {
-    const ERC20_Interface = Erc20__factory.createInterface();
-    const allowanceCall = chainId === ChainId.ZKSYNC && tokenAddress === ETH_ZKSYNC_ADDRESS
-        ? {
-            allowFailure: true,
-            callData: EthOnZKSync_INTERFACE.encodeFunctionData("allowance", [userAddress, spenderAddresses]),
-            target: tokenAddress,
-        }
-        : {
-            allowFailure: true,
-            callData: ERC20_Interface.encodeFunctionData("allowance", [userAddress, spenderAddresses]),
-            target: tokenAddress,
-        };
-    const [result] = await ChainInteractionService(chainId).fetchState([allowanceCall]);
-    const allowance = ERC20_Interface.decodeFunctionResult("allowance", result.returnData)[0].toString();
-    return BigInt(allowance);
-}

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

@@ -1,128 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { ChainId, ChainInteractionService, ETH_ADDRESS, ETH_ZKSYNC_ADDRESS, Erc20__factory, EthOnZKSync_INTERFACE, NETWORK_LABELS, } from "@sdk";
-import { isAddress } from "viem";
-export async function getOnlyUserBalance(chainId, userAddress, tokenAddresses) {
-    const calls = [];
-    const ERC20_Interface = Erc20__factory.createInterface();
-    for (const tokenAddress of tokenAddresses.filter(t => isAddress(t))) {
-        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,
-            });
-        }
-    }
-    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 TokenService.findManyObjectPerAddress({ chainId, verified: true, items: 0 });
-    if (!tokens) {
-        log.debug("❌ Chain not supported");
-        return {
-            cached: false,
-            call: {
-                callData: [],
-                handler: () => { },
-                reducer: async () => {
-                    return {};
-                },
-            },
-        };
-    }
-    const tokenListAddresses = Object.keys(tokens).filter(t => t !== ETH_ADDRESS);
-    const ERC20_Interface = Erc20__factory.createInterface();
-    const calls = [];
-    for (const tokenAddress of tokenListAddresses) {
-        calls.push({
-            allowFailure: true,
-            callData: ERC20_Interface.encodeFunctionData("balanceOf", [user]),
-            target: tokenAddress,
-        });
-    }
-    /** Only if the route is called from mainnet */
-    if (!!tokenAddresses && tokenAddresses?.length > 0) {
-        for (const externalTokenAddress of tokenAddresses) {
-            calls.push({
-                allowFailure: true,
-                callData: ERC20_Interface.encodeFunctionData("balanceOf", [user]),
-                target: externalTokenAddress,
-            }, {
-                allowFailure: true,
-                callData: ERC20_Interface.encodeFunctionData("decimals"),
-                target: externalTokenAddress,
-            }, {
-                allowFailure: true,
-                callData: ERC20_Interface.encodeFunctionData("symbol"),
-                target: externalTokenAddress,
-            });
-        }
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                const res = {};
-                for (let j = 0; j < tokenListAddresses.length; j++) {
-                    const tokenAddress = tokenListAddresses[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: tokens[tokenAddress]?.decimals,
-                        symbol: tokens[tokenAddress]?.symbol,
-                    };
-                }
-                if (!!tokenAddresses && tokenAddresses?.length > 0) {
-                    for (let j = 0; j < tokenAddresses.length; j++) {
-                        const externalTokenAddress = tokenAddresses[j];
-                        try {
-                            res[externalTokenAddress] = {
-                                balance: ERC20_Interface.decodeFunctionResult("balanceOf", result[Object.keys(tokens)?.length + 3 * j])[0]?.toString(),
-                                decimals: ERC20_Interface.decodeFunctionResult("decimals", result[Object.keys(tokens)?.length + 3 * j + 1])[0]?.toString(),
-                                symbol: ERC20_Interface.decodeFunctionResult("symbol", result[Object.keys(tokens)?.length + 3 * j + 2])[0]?.toString(),
-                            };
-                        }
-                        catch (error) {
-                            // If it fails we don't return the token info
-                            log.local(`❌ Failed to call balanceOf, decimals or symbol for ${externalTokenAddress} on ${chainId}`);
-                        }
-                    }
-                }
-                return res;
-            },
-        },
-    };
-}

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

@@ -1,22 +0,0 @@
-import { Erc20__factory } from "@sdk";
-export async function getTokenInfo(address) {
-    const ERC20_Interface = Erc20__factory.createInterface();
-    const read = ["symbol", "name", "decimals"];
-    const calls = read.map(fn => ({
-        allowFailure: false,
-        callData: ERC20_Interface.encodeFunctionData(fn),
-        target: address,
-    }));
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                return read.reduce((res, fn, index) => Object.assign(res, {
-                    [fn]: ERC20_Interface.decodeFunctionResult(fn, result[index])[0],
-                }), {});
-            },
-        },
-    };
-}