@merkl/api 0.9.15

package/dist/src/jobs/set-dungeon-keeper.js

@@ -0,0 +1,82 @@
+import { Client } from "@notionhq/client";
+import { Client as DiscordClient, GatewayIntentBits } from "discord.js";
+import moment from "moment";
+const notion = new Client({ auth: process.env.NOTION_TOKEN });
+const discord = new DiscordClient({ intents: [GatewayIntentBits.GuildMembers] });
+const NOTION_EMAIL_TO_DISCORD_ID = {
+    picodes: "thepicodes",
+    hugo: "ugolxt",
+    alex: "wombomango",
+    nileco: ".nileco",
+    thibaudb: ".greedythib",
+    gnervo: "gs8nrv",
+    vincent: "vince_merkl",
+    hicham: "lamicham_93854",
+    pveyrat: "sogipec",
+    baptiste: "baptistg",
+    clement: "clmntngl",
+};
+async function fetchEntriesForDateWithTag(databaseId, date, tag) {
+    const response = await notion.databases.query({
+        database_id: databaseId,
+        filter: {
+            and: [
+                {
+                    property: "Date",
+                    date: {
+                        equals: date,
+                    },
+                },
+                {
+                    property: "Database",
+                    select: {
+                        equals: tag,
+                    },
+                },
+            ],
+        },
+    });
+    return response.results;
+}
+async function assignRole(notionId) {
+    const discordId = NOTION_EMAIL_TO_DISCORD_ID[notionId];
+    if (!discordId)
+        throw "Discord ID not found.";
+    await discord.login(process.env.DISCORD_TOKEN);
+    const guild = await discord.guilds.cache.get("862708408711643136");
+    if (!guild)
+        throw "Guild not found.";
+    const roles = await guild.roles.fetch();
+    const teamRole = roles.find(r => r.name === "Team");
+    const dkRole = roles.find(r => r.name === "Dungeon Keeper");
+    if (!teamRole || !dkRole)
+        throw "Roles not found.";
+    const users = await guild.members.fetch();
+    for (const [_id, dkUser] of users.filter(member => member.roles.cache.has(dkRole.id))) {
+        await dkUser.roles.remove(dkRole);
+    }
+    const user = users
+        .filter(member => member.roles.cache.has(teamRole.id))
+        .find(member => member.user.tag === discordId);
+    if (!user)
+        throw "User not found";
+    await user.roles.add(dkRole);
+    const channel = await discord.channels.fetch("1328383110957633630");
+    if (!channel)
+        throw "Channel not found";
+    if (channel.isSendable()) {
+        await channel.send(`Lucky you <@${user.id}>! You're the <@&${dkRole.id}> today!`);
+    }
+}
+async function main() {
+    const entries = await fetchEntriesForDateWithTag("8546f6a84641406bafb2358762281e81", moment().format("YYYY-MM-DD"), "Dungeon Keeper");
+    const user = entries?.[0];
+    if (!user) {
+        throw "No dk found for today";
+    }
+    const notionId = (user?.properties["Qui ?"]).people[0].person.email
+        .replace("@angle.money", "")
+        .replace("@merkl.xyz", "");
+    await assignRole(notionId);
+}
+await main();

package/dist/src/jobs/update-dynamic-data.d.ts

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

package/dist/src/jobs/update-dynamic-data.js

@@ -0,0 +1,62 @@
+import { CampaignService } from "@/modules/v4/campaign";
+import { DynamicDataService } from "@/modules/v4/dynamicData/dynamicData.service";
+import { OpportunityService } from "@/modules/v4/opportunity";
+import { Campaign as CampaignEnum } from "@sdk";
+import moment from "moment";
+// ─── Required Env Variables ──────────────────────────────────────────────────
+const chainId = Number(process.env.CHAIN_ID);
+if (!chainId)
+    throw new Error("Environment variable CHAIN_ID is required.");
+// ─── Update Dynamic Data (APR / TVL / Daily Rewards) ─────────────────────────
+const main = async () => {
+    const liveCampaigns = (await CampaignService.getLiveCampaigns({ computeChainId: chainId })).map(c => {
+        return {
+            amount: c.amount,
+            campaignId: c.campaignId,
+            mainParameter: c.Opportunity.identifier,
+            campaignParameters: c.params,
+            campaignSubType: c.subType,
+            campaignType: CampaignEnum[c.type],
+            chainId: c.distributionChainId,
+            computeChainId: c.computeChainId,
+            creator: c.creatorAddress,
+            endTimestamp: Number(c.endTimestamp),
+            rewardToken: c.RewardToken.address,
+            startTimestamp: Number(c.startTimestamp),
+            index: 0,
+        };
+    });
+    await DynamicDataService.updateForCampaigns(liveCampaigns);
+    // Update status of opportunities
+    // 1. Get current live opportunities
+    const liveOpportunities = await OpportunityService.findLiveWithCampaigns(chainId);
+    // 2. For each currently live opportunities, infer its updated status by looping through its campaigns
+    const now = moment().unix();
+    for (const opportunity of liveOpportunities) {
+        let status = "NONE";
+        const campaigns = opportunity.campaigns;
+        for (const campaign of campaigns) {
+            if (status !== "LIVE" && campaign.endTimestamp < now)
+                status = "PAST";
+            else if (campaign.startTimestamp < now && campaign.endTimestamp > now)
+                status = "LIVE";
+            else if (status !== "LIVE" && campaign.startTimestamp > now)
+                status = "SOON";
+        }
+        await OpportunityService.updateStatus(opportunity.id, status);
+    }
+    // 3. Update the status of the opportunities associated to future campaigns
+    const futureOpportunityIds = (await CampaignService.getFutureCampaigns({ computeChainId: chainId })).map(c => c.Opportunity.id);
+    const liveOpportunityIds = (await CampaignService.getLiveCampaigns({ computeChainId: chainId })).map(c => c.Opportunity.id);
+    await OpportunityService.updateMany(futureOpportunityIds?.filter(opportunityId => !liveOpportunityIds.includes(opportunityId)), { status: "SOON" });
+    // 4. Update the status of the opportunities associated to live campaigns
+    await OpportunityService.updateMany(liveOpportunityIds, { status: "LIVE" });
+};
+try {
+    await main();
+    process.exit(0);
+}
+catch (err) {
+    console.error(err);
+    process.exit(1);
+}

package/dist/src/jobs/update-euler-vaults.d.ts

@@ -0,0 +1 @@
+export declare function updateEulerVaultsCollatInDatabase(): Promise<void>;

package/dist/src/jobs/update-euler-vaults.js

@@ -0,0 +1,122 @@
+import { Redis } from "@/cache";
+import { LoggedEntityType, getEulerV2Vaults } from "@/engine/dynamicData/utils/getEulerV2Vaults";
+import { fetchEulerVaultName } from "@/engine/erc20SubTypeProcessors/helpers/eulerVaultNames";
+import { batchMulticallCallWithRetry } from "@/utils/generic";
+import { log } from "@/utils/logger";
+import { apiDbClient } from "@db";
+import { ERC20Interface, EULER_ADDRESSES, EulerEVKInterface, EulerVaultLensInterface, NETWORK_LABELS, eulerChainIds, } from "@sdk";
+import _ from "lodash";
+async function computeCollatListAndReturnVaults(chainId, vaults) {
+    let vaultsPerChain = [];
+    /** Extra calls batch to get the collateral addresses */
+    const resCollat = await batchMulticallCallWithRetry(chainId, {
+        calls: vaults
+            .map(vault => vault.address)
+            .map(vaultAddress => {
+            return {
+                allowFailure: true,
+                callData: EulerVaultLensInterface.encodeFunctionData("getRecognizedCollateralsLTVInfo", [vaultAddress]),
+                target: EULER_ADDRESSES[chainId].VAULT_LENS,
+            };
+        }),
+    });
+    const callsCollatUnderlying = [];
+    const callsCollatUnderlyingSymbol = [];
+    for (const [index, vault] of vaults.entries()) {
+        const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
+        for (const collat of collatArray) {
+            if (!!vault.collaterals &&
+                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase()))
+                continue;
+            log.info(`🦭 found new collateral ${collat.collateral} for vault ${vault.address} (${NETWORK_LABELS[chainId]})`);
+            callsCollatUnderlying.push({
+                allowFailure: true,
+                callData: EulerEVKInterface.encodeFunctionData("asset"),
+                target: collat.collateral,
+            }, {
+                allowFailure: true,
+                callData: EulerEVKInterface.encodeFunctionData("symbol"),
+                target: collat.collateral,
+            });
+        }
+    }
+    const resCollatUnderlying = await batchMulticallCallWithRetry(chainId, {
+        calls: callsCollatUnderlying,
+    });
+    for (let i = 0; i < resCollatUnderlying.length; i = i + 2) {
+        const underlyingToken = EulerEVKInterface.decodeFunctionResult("asset", resCollatUnderlying[i].returnData)[0];
+        callsCollatUnderlyingSymbol.push({
+            allowFailure: true,
+            callData: ERC20Interface.encodeFunctionData("symbol"),
+            target: underlyingToken,
+        });
+    }
+    const resCollatUnderlyingSymbol = await batchMulticallCallWithRetry(chainId, {
+        calls: callsCollatUnderlyingSymbol,
+    });
+    vaultsPerChain = vaultsPerChain.concat((await Promise.all(vaults.map(async (vault, index) => {
+        const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
+        if (!vault.collaterals)
+            vault.collaterals = [];
+        let offset = 0;
+        for (const [_index, collat] of collatArray.entries()) {
+            // _ Check whether the collat was already registered
+            if (!!vault.collaterals &&
+                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase())) {
+                offset += 1;
+                continue;
+            }
+            const symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCollatUnderlyingSymbol[_index - offset].returnData)[0];
+            vault.collaterals.push({
+                address: collat.collateral,
+                symbolCollateral: EulerEVKInterface.decodeFunctionResult("symbol", resCollatUnderlying[2 * (_index - offset) + 1].returnData)[0],
+                symbolUnderlying,
+                borrowLTV: collat.borrowLTV.toString(),
+                nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolUnderlying,
+            });
+        }
+        return { ...vault };
+    }))));
+    return vaultsPerChain;
+}
+export async function updateEulerVaultsCollatInDatabase() {
+    // 0_ Fetch all euler vaults from database
+    const vaults = await apiDbClient.logged.findMany({
+        where: { type: LoggedEntityType.EULER },
+    });
+    const clonedVaults = _.cloneDeep(vaults);
+    let toUpdateVaults = [];
+    // 1_ Return all vaults already stored with their collateral updated
+    const res = await Promise.all(eulerChainIds.map(async (chainId) => computeCollatListAndReturnVaults(chainId, clonedVaults.filter(entity => entity.chainId === chainId).map(entity => entity.entityData))));
+    for (const resPerChain of res) {
+        if (!!resPerChain && resPerChain.length > 0) {
+            toUpdateVaults = toUpdateVaults.concat(resPerChain.filter(updatedVault => {
+                return (updatedVault.collaterals.length >
+                    vaults.find(vault => vault.address?.toLowerCase() === updatedVault.address.toLowerCase())
+                        ?.entityData?.collaterals.length);
+            }));
+        }
+    }
+    // 2_ Update the API database
+    if (toUpdateVaults.length > 0) {
+        try {
+            for (const vault of toUpdateVaults) {
+                await apiDbClient.logged.updateMany({
+                    where: {
+                        address: vault.address,
+                        chainId: vault.chainId,
+                    },
+                    data: {
+                        entityData: vault,
+                    },
+                });
+            }
+            log.info(`✅ successfully updated ${toUpdateVaults.length} vault(s) collaterals in API database ('Logged' table)`);
+        }
+        catch {
+            throw new Error("Error while updating vaults to API database (`Logged` table)");
+        }
+    }
+}
+await updateEulerVaultsCollatInDatabase();
+await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());

package/dist/src/jobs/update-uniswap-v4-pools.d.ts

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

package/dist/src/jobs/update-uniswap-v4-pools.js

@@ -0,0 +1,14 @@
+import { Redis } from "@/cache";
+import { UniswapV4Service } from "@/modules/v4/uniswapV4";
+async function main() {
+    try {
+        await Redis.safeSet("UniswapV4Pools", await UniswapV4Service.getPools());
+        process.exit(0);
+    }
+    catch (err) {
+        console.error("Failed to update Uniswap V4 pools cache.");
+        console.error(err);
+        process.exit(1);
+    }
+}
+await main();

package/dist/src/libs/computeFee.d.ts

@@ -0,0 +1,4 @@
+import { type Campaign, type MerklChainId, type campaignConfig } from "@sdk";
+export declare const computeFee: (chainId: MerklChainId, config: campaignConfig<Campaign>) => Promise<{
+    fee: string;
+}>;

package/dist/src/libs/computeFee.js

@@ -0,0 +1,34 @@
+import { BASE_9, DistributionCreatorInterface, registry, } from "@sdk";
+import { BigNumber } from "ethers";
+import { batchMulticallCallWithRetry } from "../utils/generic";
+export const computeFee = async (chainId, config) => {
+    if (!config.creator) {
+        throw new Error("Creator is required");
+    }
+    const distributionCreator = registry(chainId)?.Merkl?.DistributionCreator;
+    const calls = [
+        {
+            allowFailure: true,
+            target: distributionCreator,
+            callData: DistributionCreatorInterface.encodeFunctionData("campaignSpecificFees", [config.campaignType]),
+        },
+        {
+            allowFailure: true,
+            target: distributionCreator,
+            callData: DistributionCreatorInterface.encodeFunctionData("feeRebate", [config.creator]),
+        },
+    ];
+    const result = await batchMulticallCallWithRetry(chainId, {
+        calls,
+    });
+    const campaignSpecificFees = BigNumber.from(DistributionCreatorInterface.decodeFunctionResult("campaignSpecificFees", result[0].returnData)[0]);
+    const feeRebate = BigNumber.from(DistributionCreatorInterface.decodeFunctionResult("feeRebate", result[1].returnData)[0]);
+    const baseFeesValue = campaignSpecificFees.eq("1")
+        ? BigNumber.from(0)
+        : campaignSpecificFees.eq("0")
+            ? BigNumber.from(30000000)
+            : campaignSpecificFees;
+    return {
+        fee: baseFeesValue.mul(BASE_9.sub(feeRebate)).div(BASE_9).toString(),
+    };
+};

package/dist/src/libs/deprecated-merklv3/index.d.ts

@@ -0,0 +1,5 @@
+import type { CampaignsCacheUpdaterReturnType } from "@/backgroundJobs/jobs/campaignsCacheUpdater";
+import { AMM, type ChainId, type MerklAPIType } from "@sdk";
+import type { MerklChainData } from "../../types";
+export declare function getClamsInfo(chainIds?: number[] | readonly ChainId[], AMMs?: Lowercase<keyof typeof AMM>[], user?: string, onlyLive?: boolean): Promise<MerklAPIType>;
+export declare function campaignsToOldFormat(campaignData: CampaignsCacheUpdaterReturnType, merklChainData: MerklChainData): MerklAPIType[number];

package/dist/src/libs/deprecated-merklv3/index.js

@@ -0,0 +1,184 @@
+import { Redis } from "@/cache";
+import { RewardConvertorService } from "@/modules/v4/reward/reward.converter";
+import { AMM, ANGLE_NETWORKS, Campaign, NETWORK_LABELS, } from "@sdk";
+import Big from "big.js";
+import { utils } from "ethers";
+import { log } from "../../utils/logger";
+const fetchCachedData = async (chainIds, onlyLive) => {
+    if (onlyLive === undefined) {
+        onlyLive = false;
+    }
+    const cacheKeys = chainIds.map(chainId => onlyLive ? `LiveCampaignsOldFormat_${chainId}` : `CampaignsOldFormat_${chainId}`);
+    return await Redis.findMany(cacheKeys);
+};
+export async function getClamsInfo(chainIds, AMMs, user, onlyLive) {
+    if (!chainIds && !user && !AMMs) {
+        const cachedData = await fetchCachedData(ANGLE_NETWORKS.merkl);
+        const result = ANGLE_NETWORKS.merkl.reduce((acc, chainId, index) => {
+            if (!cachedData[index]) {
+                log.error("Merkl cache", `Data for ${NETWORK_LABELS[chainId]} not found in cache`);
+            }
+            else {
+                acc[chainId] = cachedData[index];
+            }
+            return acc;
+        }, {});
+        return result;
+    }
+    if (!chainIds) {
+        chainIds = ANGLE_NETWORKS.merkl;
+    }
+    if (onlyLive === undefined) {
+        onlyLive = false;
+    }
+    const cachedData = await fetchCachedData(chainIds, onlyLive);
+    let chainData = [];
+    if (!!user) {
+        chainData = await Redis.findMany(chainIds.map(chainId => `MerklChainData_${chainId}`));
+    }
+    /** Parallel computation of data for each chain */
+    const result = {};
+    const promises = chainIds.map((chainId, index) => (async () => {
+        if (!cachedData[index]) {
+            log.error("Merkl cache", `Data for ${NETWORK_LABELS[chainId]} not found in cache`);
+            return;
+        }
+        log.local(`Redis: ${Object.keys(cachedData[index]?.pools ?? {}).length} pools found on ${NETWORK_LABELS[chainId]}`);
+        /** Filter pools if an AMM filter is required */
+        const filteredPools = {};
+        for (const key of Object.keys(cachedData[index]?.pools ?? {})) {
+            if (!!AMMs &&
+                AMMs.length > 0 &&
+                !!AMM[cachedData[index].pools[key].amm] &&
+                AMMs.indexOf(AMM[cachedData[index].pools[key].amm].toLowerCase()) === -1) {
+                continue;
+            }
+            filteredPools[key] = cachedData[index].pools[key];
+        }
+        cachedData[index].pools = filteredPools;
+        /** Fetch user specific data */
+        if (!!user &&
+            utils.isAddress(user) &&
+            utils.getAddress(user) !== "0xeeeeeEAaAeEEeEEeEeEEEeEEeEeEEEeeeEeeeEee" &&
+            !!cachedData[index].merkleRoot) {
+            cachedData[index] = await RewardConvertorService.convertV4toMerklV2(user, chainId, cachedData[index]);
+            log.local(`Merkl: ${Object.keys(cachedData[index]?.pools ?? {}).filter(k => cachedData[index].pools[k].userBalanceToken0 > 0 ||
+                cachedData[index].pools[k].userBalanceToken1 > 0).length} pool with a user position found on ${NETWORK_LABELS[chainId]}`);
+        }
+        /** Fill result */
+        result[chainId] = cachedData[index];
+    })());
+    await Promise.all(promises);
+    return result;
+}
+export function campaignsToOldFormat(campaignData, merklChainData) {
+    const res = {};
+    res.merkleRoot = merklChainData.merkleRoot;
+    res.message = merklChainData.message;
+    res.validRewardTokens = merklChainData.validRewardTokens;
+    res.pools = {};
+    const pools = {};
+    for (const [type_mainParameter, campaigns] of Object.entries(campaignData)) {
+        // if not a CLAMM campaign, skip
+        if (!type_mainParameter.startsWith("2_")) {
+            continue;
+        }
+        const mainParameter = type_mainParameter.split("_")[1];
+        for (const campaign of Object.values(campaigns)) {
+            if (campaign.campaignType !== Campaign.CLAMM) {
+                continue;
+            }
+            if (!pools[mainParameter]) {
+                pools[mainParameter] = {
+                    alm: campaign.forwarders?.reduce((prev, curr) => {
+                        if (!prev[utils.getAddress(curr.almAddress)]) {
+                            prev[utils.getAddress(curr.almAddress)] = {
+                                ...curr,
+                                almAddress: utils.getAddress(curr.almAddress),
+                            };
+                        }
+                        else {
+                            prev[utils.getAddress(curr.almAddress)].almAPR =
+                                (!!prev[utils.getAddress(curr.almAddress)].almAPR
+                                    ? prev[utils.getAddress(curr.almAddress)].almAPR
+                                    : 0) + (curr.almAPR ?? 0);
+                        }
+                        return prev;
+                    }, {}),
+                    amm: campaign.amm,
+                    ammAlgo: campaign.ammAlgo,
+                    ammAlgoName: campaign.ammAlgoName,
+                    ammName: campaign.ammName,
+                    aprs: campaign.aprs,
+                    chainId: campaign.chainId,
+                    decimalsToken0: campaign.campaignParameters.decimalsToken0,
+                    decimalsToken1: campaign.campaignParameters.decimalsToken1,
+                    disputeLive: merklChainData.disputeLive,
+                    distributionData: [],
+                    endOfDisputePeriod: merklChainData.endOfDisputePeriod,
+                    meanAPR: campaign.apr,
+                    pool: campaign.campaignParameters.poolAddress,
+                    poolBalanceToken0: campaign.poolBalanceToken0,
+                    poolBalanceToken1: campaign.poolBalanceToken1,
+                    poolFee: Number.parseFloat(campaign.campaignParameters.poolFee),
+                    poolTotalLiquidity: campaign.poolTotalLiquidity,
+                    rewardsPerToken: {},
+                    symbolToken0: campaign.campaignParameters.symbolToken0,
+                    symbolToken1: campaign.campaignParameters.symbolToken1,
+                    tick: campaign.tick,
+                    token0: campaign.campaignParameters.token0,
+                    token1: campaign.campaignParameters.token1,
+                    tvl: campaign.tvl,
+                };
+            }
+            else {
+                pools[mainParameter].meanAPR += campaign.apr;
+                if (!!campaign.aprs) {
+                    for (const [key, value] of Object.entries(campaign.aprs)) {
+                        pools[mainParameter].aprs[key] =
+                            (!!pools[mainParameter].aprs[key] ? pools[mainParameter].aprs[key] : 0) + (value ?? 0);
+                    }
+                }
+                if (!!campaign.forwarders) {
+                    for (const almDetails of campaign.forwarders) {
+                        if (!pools[mainParameter]?.alm?.[utils.getAddress(almDetails.almAddress)]) {
+                            pools[mainParameter].alm[utils.getAddress(almDetails.almAddress)] = almDetails;
+                        }
+                        else {
+                            pools[mainParameter].alm[utils.getAddress(almDetails.almAddress)].almAPR =
+                                (!!pools[mainParameter].alm[utils.getAddress(almDetails.almAddress)].almAPR
+                                    ? pools[mainParameter].alm[utils.getAddress(almDetails.almAddress)].almAPR
+                                    : 0) + (almDetails.almAPR ?? 0);
+                        }
+                    }
+                }
+            }
+            const amountDecimal = Number.parseFloat(new Big(campaign.amount).div(new Big(10).pow(campaign.campaignParameters.decimalsRewardToken)).toString());
+            pools[mainParameter].distributionData.push({
+                amount: amountDecimal,
+                apr: campaign?.apr,
+                blacklist: campaign.campaignParameters.blacklist,
+                blacklistedBalance0: campaign.blacklistedBalance0,
+                blacklistedBalance1: campaign.blacklistedBalance1,
+                blacklistedLiquidity: campaign.blacklistedLiquidity,
+                breakdown: {},
+                decimalsRewardToken: campaign.campaignParameters.decimalsRewardToken,
+                endTimestamp: campaign.endTimestamp,
+                id: campaign.campaignId,
+                isLive: campaign.isLive,
+                isMock: campaign.isMock,
+                isOutOfRangeIncentivized: campaign.campaignParameters.isOutOfRangeIncentivized,
+                propFees: campaign.campaignParameters.weightFees / 100,
+                propToken0: campaign.campaignParameters.weightToken0 / 100,
+                propToken1: campaign.campaignParameters.weightToken1 / 100,
+                rewardToken: campaign.rewardToken,
+                startTimestamp: campaign.startTimestamp,
+                symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+                unclaimed: 0,
+                whitelist: campaign.campaignParameters.whitelist,
+            });
+        }
+        res.pools = pools;
+    }
+    return res;
+}

package/dist/src/libs/getTokensList.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @deprecated The whole file is deprecated
+ */
+export interface Token {
+    readonly name: string;
+    readonly address: string;
+    readonly decimals: number;
+    readonly symbol: string;
+    readonly useInSwap?: boolean;
+    readonly hasPermit?: boolean;
+    readonly permitVersion?: string;
+    readonly logoURI?: string;
+    readonly tags?: string[];
+    readonly wrappingMethod?: "Curve" | "BorrowStaker" | "Aave Matic Market" | "Wrap Native" | "Convex";
+    readonly underlyingTokens?: string[];
+}
+export interface TokenInfoListType {
+    [symbol: string]: Token;
+}
+/**
+ * @deprecated
+ */
+export declare const getTokensListWithCache: () => Promise<TokenList>;

package/dist/src/libs/getTokensList.js

@@ -0,0 +1,19 @@
+import { Redis } from "@/cache";
+import axios from "axios";
+import { log } from "../utils/logger";
+async function getTokensList() {
+    let res = {};
+    try {
+        res = (await axios.get("https://raw.githubusercontent.com/AngleProtocol/angle-token-list/main/ERC20_LIST.json", {
+            timeout: 5000,
+        })).data[0];
+    }
+    catch (e) {
+        log.error("getTokensList failed", e);
+    }
+    return res;
+}
+/**
+ * @deprecated
+ */
+export const getTokensListWithCache = async () => await Redis.getOrSet("TokenList", getTokensList);

package/dist/src/libs/merklChainData.d.ts

@@ -0,0 +1,4 @@
+import { type MerklChainId } from "@sdk";
+import type { MerklChainData } from "../types";
+export declare function merklChainData(chainId: MerklChainId): Promise<MerklChainData>;
+export declare const merklChainDataWithCache: (chainId: MerklChainId) => Promise<any>;