@merkl/api 0.9.15

package/dist/src/engine/dynamicData/utils/getUniswapV4Pools.js

@@ -0,0 +1,183 @@
+import { Redis } from "@/cache";
+import { log } from "@/utils/logger";
+import { providers } from "@/utils/providers";
+import { apiDbClient } from "@db";
+import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, getContractCreationBlock, } from "@sdk";
+import { safeFetchLogs } from "./fetchLogs";
+import { LoggedEntityType } from "./getEulerV2Vaults";
+const UNIV4_CHAINIDS = Object.keys(UniswapV4Addresses).map((x) => Number(x));
+export async function getUniswapV4Pools() {
+    const pools = {};
+    // 0_ Fetch all euler vaults from database
+    const storedPools = await apiDbClient.logged.findMany({
+        where: { type: LoggedEntityType.UNISWAP_V4 },
+    });
+    const res = await Promise.all(UNIV4_CHAINIDS.map(async (chainId) => {
+        chainId = chainId;
+        const perChainIdRes = {};
+        const poolManagerAddress = UniswapV4Addresses[chainId]?.PoolManager ?? NULL_ADDRESS;
+        const jsonRPCprovider = providers[chainId];
+        try {
+            // 1_ Get latest euler vaults from chain
+            const storedPoolsPerChain = storedPools.filter(pool => pool.chainId === chainId);
+            log.info(`found ${storedPoolsPerChain.length} already stored pools on ${NETWORK_LABELS[chainId]}`);
+            let fromBlock;
+            if (storedPoolsPerChain.length > 0) {
+                fromBlock = Math.max(...storedPoolsPerChain.map(x => x.fetchAtBlock)) + 1;
+            }
+            else {
+                fromBlock = await getContractCreationBlock(poolManagerAddress, jsonRPCprovider);
+            }
+            const toBlock = await jsonRPCprovider.getBlockNumber();
+            const logs = await safeFetchLogs(chainId, // TODO: rm type enforcing
+            [UniswapV4PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock
+            // fromBlock + 10_000
+            );
+            const decodedPools = await Promise.all(logs.map(async (log) => {
+                const [id, currency0, currency1, fee, tickSpacing, hooks] = UniswapV4PoolManagerInterface.decodeEventLog("Initialize", log.data, log.topics);
+                // Respect typing
+                return {
+                    poolId: id,
+                    chainId: chainId,
+                    currency0: currency0,
+                    currency1: currency1,
+                    tickSpacing: tickSpacing,
+                    lpFee: fee,
+                    hooks: hooks,
+                    fetchedAtBlock: Number(log.blockNumber),
+                };
+            }));
+            log.local(`fetched ${decodedPools.length} pool(s) on ${NETWORK_LABELS[chainId] ?? "Sepolia"} between blocks ${fromBlock} and ${toBlock}`);
+            /** Extra calls batch to get the collateral addresses */
+            const resCurrencies = await ChainInteractionService(chainId).fetchState(decodedPools.flatMap(pool => {
+                return [
+                    {
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("symbol"),
+                        target: pool.currency0,
+                    },
+                    {
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("decimals"),
+                        target: pool.currency0,
+                    },
+                    {
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("symbol"),
+                        target: pool.currency1,
+                    },
+                    {
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("decimals"),
+                        target: pool.currency1,
+                    },
+                ].filter(x => x.target !== NULL_ADDRESS);
+            }));
+            let index = 0;
+            for (const pool of decodedPools) {
+                let symbolCurrency0 = "UNKNOWN";
+                let decimalsCurrency0 = 18;
+                if (pool.currency0 !== NULL_ADDRESS) {
+                    try {
+                        symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index].returnData)[0];
+                        if (symbolCurrency0.includes("/") || symbolCurrency0.includes("\u0000")) {
+                            symbolCurrency0 = "INVALID";
+                        }
+                        decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 1].returnData)[0];
+                    }
+                    catch {
+                        log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency0 ${pool.currency0} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                    }
+                }
+                else {
+                    symbolCurrency0 = "ETH";
+                    decimalsCurrency0 = 18;
+                    index -= 2;
+                }
+                let symbolCurrency1 = "UNKNOWN";
+                let decimalsCurrency1 = 18;
+                if (pool.currency1 !== NULL_ADDRESS) {
+                    try {
+                        symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index + 2].returnData)[0];
+                        if (symbolCurrency1.includes("/") || symbolCurrency1.includes("\u0000")) {
+                            symbolCurrency1 = "INVALID";
+                        }
+                        decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 3].returnData)[0];
+                    }
+                    catch {
+                        log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency1 ${pool.currency1} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                    }
+                }
+                else {
+                    symbolCurrency1 = "ETH";
+                    decimalsCurrency1 = 18;
+                    index -= 2;
+                }
+                const id = pool.poolId;
+                perChainIdRes[id ?? "unknownKey"] = {
+                    chainId: pool.chainId,
+                    currency0: pool.currency0,
+                    currency1: pool.currency1,
+                    decimalsCurrency0,
+                    decimalsCurrency1,
+                    hooks: pool.hooks,
+                    fetchedAtBlock: pool.fetchedAtBlock,
+                    lpFee: pool.lpFee,
+                    poolId: id,
+                    poolKey: pool.poolKey,
+                    symbolCurrency0,
+                    symbolCurrency1,
+                    tickSpacing: pool.tickSpacing,
+                };
+                index += 4;
+            }
+        }
+        catch (e) {
+            log.error(`issue when fetching UniswapV4 pools on ${NETWORK_LABELS[chainId]}`, e);
+        }
+        return perChainIdRes;
+    }));
+    UNIV4_CHAINIDS.forEach((chainId, i) => {
+        if (!!res[i])
+            pools[chainId] = res[i];
+    });
+    // Update the API database
+    const tableData = Object.values(pools).flatMap(pools => Object.values(pools));
+    for (const chainId of UNIV4_CHAINIDS) {
+        if (tableData.filter(p => p.chainId === chainId).length > 0) {
+            try {
+                await apiDbClient.logged.createMany({
+                    data: tableData
+                        .filter(point => point.chainId === chainId)
+                        .map(pool => ({
+                        fetchAtBlock: pool.fetchedAtBlock,
+                        caughtFromAddress: UniswapV4Addresses[pool.chainId]?.PoolManager ?? NULL_ADDRESS,
+                        chainId: pool.chainId,
+                        entityData: pool,
+                        id: Bun.hash(`${pool.poolId}-${pool.chainId}`).toString(),
+                        type: LoggedEntityType.UNISWAP_V4,
+                    })),
+                });
+                log.info(`✅ successfully saved vaults to API database ('Logged' table) on ${NETWORK_LABELS[chainId]}`);
+            }
+            catch (e) {
+                log.error("getUniswapV4Pools/LoggedTableUpdate", e);
+                throw new Error(`Error while saving UniV4 pools to API database ('Logged' table) on ${NETWORK_LABELS[chainId]}`);
+            }
+        }
+    }
+    log.info(`✅ successfully fetched ${tableData.length} new pool(s) on UniswapV4`);
+    // _ Merge previoulsy stored pools with newly fetched ones
+    // TODO optimize this part
+    if (storedPools.length > 0) {
+        for (const pool of storedPools) {
+            const chainId = pool.chainId;
+            if (!pools[chainId])
+                pools[chainId] = {};
+            pools[chainId][pool.entityData.poolId] = pool.entityData;
+        }
+    }
+    log.info("👋 exiting getUniswapV4Pools");
+    return pools;
+}
+export const getUniswapV4PoolsWithCache = async () => await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools);

package/dist/src/engine/erc20SubTypeProcessors/GenericProcessor.d.ts

@@ -0,0 +1,99 @@
+import type { Pricer } from "@/utils/pricer";
+import { type CallDto, type Campaign, type CampaignParameters } from "@sdk";
+import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
+import { type tokenType, type tokenTypeStruct } from "./helpers/tokenType";
+export declare enum Round {
+    one = "round1",
+    two = "round2",
+    three = "round3",
+    four = "round4"
+}
+export type callType = {
+    key: any;
+    call: any;
+    target: any;
+    metaData?: any;
+    optional?: boolean;
+};
+export type mandatoryCallKeys = {
+    type: tokenType;
+    protocol: string;
+    tokenAddress: string;
+    blacklistedSupply: string;
+    totalSupply: string;
+    whitelistedSupply: string;
+} & stakingKeys;
+export type stakingKeys = {
+    lockNFT: string;
+    eip712DomainName: string;
+    stakingName: string;
+    stakingSymbol: string;
+    isStaking: string;
+};
+export type callKeys = mandatoryCallKeys & {
+    [key: string]: string;
+};
+export type dataRaw = {
+    protocol: string;
+    tokenAddress: string;
+    blacklistedSupply: string;
+    totalSupply: string;
+    whitelistedSupply: string;
+} & stakingKeys;
+export type dataType = {
+    protocol: string;
+    type: tokenType;
+    tokenAddress: string;
+    totalSupply: number;
+    blacklistedSupply: number;
+    tvl: number;
+    cardName: string;
+    priceTargetToken: number;
+    whitelistedSupplyTargetToken: number;
+};
+/**
+ * Generic Processor to compute dynamic data of ERC20 tokens
+ *
+ * @params Input - Sets of value that will be passed from rounds to rounds in order to query the blockchain
+ * @params DataRaw - Raw data output from the view function calls
+ * @params Output - Final output of the processor
+ */
+export declare class GenericProcessor<Input extends callKeys, DataRaw extends dataRaw, Output extends dataType> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    stakingRounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    debug: boolean;
+    processingRound1(_typeInfo: DataRaw): void;
+    processingRound2(_typeInfo: DataRaw, _campaign?: CampaignParameters<ERC20SupportedCampaignType>): void;
+    processingRound3(_typeInfo: DataRaw): void;
+    processingRound4(_typeInfo: DataRaw): void;
+    handleWhiteListBlacklistRound5(typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): {
+        whitelistedSupplyTargetToken: number;
+        totalSupply: any;
+        blacklistedSupply: number;
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: DataRaw, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<Output>;
+    computeRound1(type: tokenType, typeInfo: DataRaw): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign?: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<ERC20SupportedCampaignType>, pricer: Pricer): Promise<tokenTypeStruct>;
+    generateWhitelistCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): CallDto[];
+    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): CallDto[];
+    decodeListedSupply(index: number, decimals: number, list: string[], calls: string[]): string;
+    decodeRound(round: callType[], index: number, calls: string[], type: tokenType, data: DataRaw): void;
+    decodePreviousRound(round: Round, calls: string[], data: DataRaw, type: tokenType, index: number): void;
+    decodePreviousStakingRound(round: Round, calls: string[], data: DataRaw, type: tokenType, index: number): void;
+    encodeRound(round: callType[], callInfo: Input, type: tokenType): CallDto[];
+    encodeNextRound(round: Round, type: tokenType, data: DataRaw): CallDto[];
+    encodeStakingNextRound(round: Round, type: tokenType, data: DataRaw): CallDto[];
+}

package/dist/src/engine/erc20SubTypeProcessors/GenericProcessor.js

@@ -0,0 +1,329 @@
+import { decodeCall } from "@/utils/decodeCalls";
+import { createCall } from "@/utils/encodeCalls";
+import { generateCardName } from "@/utils/generateCardName";
+import { generateIcons } from "@/utils/generateIcons";
+import { BN2Number } from "@sdk";
+import { tokenTypeToProtocol } from "./helpers/tokenType";
+export var Round;
+(function (Round) {
+    Round["one"] = "round1";
+    Round["two"] = "round2";
+    Round["three"] = "round3";
+    Round["four"] = "round4";
+})(Round || (Round = {}));
+/**
+ * Generic Processor to compute dynamic data of ERC20 tokens
+ *
+ * @params Input - Sets of value that will be passed from rounds to rounds in order to query the blockchain
+ * @params DataRaw - Raw data output from the view function calls
+ * @params Output - Final output of the processor
+ */
+export class GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    stakingRounds = {
+        round1: [
+            { key: "lockNFT", call: "lockNFT", target: "stakingContract", optional: true },
+            { key: "eip712DomainName", call: "eip712DomainName", target: "stakingContract", optional: true },
+            { key: "stakingName", call: "name", target: "stakingContract", optional: true },
+            { key: "stakingSymbol", call: "symbol", target: "stakingContract", optional: true },
+        ],
+        round2: [{ key: "stakingSymbol", call: "symbol", target: "lockNFT", optional: true }],
+        round3: [],
+        round4: [],
+    };
+    debug = false;
+    processingRound1(_typeInfo) { }
+    processingRound2(_typeInfo, _campaign) { }
+    processingRound3(_typeInfo) { }
+    processingRound4(_typeInfo) { }
+    handleWhiteListBlacklistRound5(typeInfo, campaign) {
+        const totalSupply = BN2Number(typeInfo.totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const whitelistedSupply = Number(typeInfo.whitelistedSupply);
+        const blacklistedSupply = Number(typeInfo.blacklistedSupply);
+        let whitelistedSupplyTargetToken = whitelistedSupply ? whitelistedSupply : totalSupply - blacklistedSupply;
+        whitelistedSupplyTargetToken = whitelistedSupplyTargetToken ? whitelistedSupplyTargetToken : 0.00001;
+        return {
+            whitelistedSupplyTargetToken,
+            totalSupply,
+            blacklistedSupply,
+        };
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceTargetToken = (await pricer.get({ symbol: campaign.campaignParameters.symbolTargetToken })) ?? 0;
+        const tvl = whitelistedSupplyTargetToken * priceTargetToken;
+        return {
+            protocol: typeInfo.protocol,
+            type,
+            whitelistedSupplyTargetToken,
+            totalSupply,
+            priceTargetToken,
+            tvl,
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+    computeRound1(type, typeInfo) {
+        typeInfo = { type, ...tokenTypeToProtocol[type], ...typeInfo };
+        this.processingRound1(typeInfo);
+        let calls = this.encodeNextRound(Round.one, type, typeInfo);
+        if (typeInfo.isStaking === "true") {
+            calls = calls.concat(this.encodeStakingNextRound(Round.one, type, typeInfo));
+        }
+        if (this.debug) {
+            console.log("Round 1", {
+                type: type,
+                calls,
+                typeInfo,
+            });
+        }
+        return {
+            type: type,
+            calls,
+            typeInfo,
+        };
+    }
+    computeRound2(index, type, typeInfo, calls, campaign) {
+        this.decodePreviousRound(Round.one, calls, typeInfo, type, index);
+        if (typeInfo.isStaking === "true") {
+            this.decodePreviousStakingRound(Round.one, calls, typeInfo, type, index + this.rounds.round1.length);
+        }
+        this.processingRound2(typeInfo, campaign);
+        let nextCalls = this.encodeNextRound(Round.two, type, typeInfo);
+        if (typeInfo.isStaking === "true") {
+            nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.two, type, typeInfo));
+        }
+        if (this.debug) {
+            console.log("Round 2", {
+                type: type,
+                calls: nextCalls,
+                typeInfo,
+            });
+        }
+        return {
+            type: type,
+            calls: nextCalls,
+            typeInfo,
+        };
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        this.decodePreviousRound(Round.two, calls, typeInfo, type, index);
+        if (typeInfo.isStaking === "true") {
+            this.decodePreviousStakingRound(Round.two, calls, typeInfo, type, index + this.rounds.round2.length);
+        }
+        this.processingRound3(typeInfo);
+        let nextCalls = this.encodeNextRound(Round.three, type, typeInfo);
+        if (typeInfo.isStaking === "true") {
+            nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.three, type, typeInfo));
+        }
+        if (this.debug) {
+            console.log("Round 3", {
+                type: type,
+                calls: nextCalls,
+                typeInfo,
+            });
+        }
+        return {
+            type: type,
+            calls: nextCalls,
+            typeInfo,
+        };
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
+        const whitelistedLiquidityCalls = this.generateWhitelistCall(type, typeInfo, campaign);
+        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
+        if (typeInfo.isStaking === "true") {
+            this.decodePreviousStakingRound(Round.three, calls, typeInfo, type, index + this.rounds.round3.length);
+        }
+        this.processingRound4(typeInfo);
+        let nextCalls = this.encodeNextRound(Round.four, type, typeInfo);
+        if (typeInfo.isStaking === "true") {
+            nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.four, type, typeInfo));
+        }
+        if (this.debug) {
+            console.log("Round 4", {
+                type: type,
+                calls: nextCalls,
+                typeInfo,
+            });
+        }
+        return {
+            type: type,
+            calls: whitelistedLiquidityCalls.concat(blacklistedLiquidityCalls).concat(nextCalls),
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
+        typeInfo.whitelistedSupply = this.decodeListedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.whitelist, calls);
+        index = index + campaign.campaignParameters.whitelist.length;
+        typeInfo.blacklistedSupply = this.decodeListedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        index = index + campaign.campaignParameters.blacklist.length;
+        this.decodePreviousRound(Round.four, calls, typeInfo, type, index);
+        if (typeInfo.isStaking === "true") {
+            this.decodePreviousStakingRound(Round.four, calls, typeInfo, type, index + this.rounds.round4.length);
+        }
+        const outputInfo = (await this.processingRound5(index, type, typeInfo, calls, campaign, pricer));
+        if (this.debug) {
+            console.log("Round 5", {
+                type: type,
+                calls: [],
+                typeInfo: {
+                    ...outputInfo,
+                    icons: generateIcons(type, typeInfo, campaign),
+                },
+            });
+        }
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...outputInfo,
+                icons: generateIcons(type, typeInfo, campaign),
+            },
+        };
+    }
+    generateWhitelistCall(type, typeInfo, campaign) {
+        const whitelistedLiquidityCalls = [];
+        if (campaign.campaignParameters.whitelist.length > 0) {
+            for (const whitelistedAddress of campaign.campaignParameters.whitelist) {
+                if (!campaign.campaignParameters.blacklist.includes(whitelistedAddress)) {
+                    whitelistedLiquidityCalls.push(createCall(typeInfo.tokenAddress, "balanceOf", type, whitelistedAddress));
+                }
+            }
+        }
+        return whitelistedLiquidityCalls;
+    }
+    generateBlackListCall(type, typeInfo, campaign) {
+        const blacklistedLiquidityCalls = [];
+        if (campaign.campaignParameters.blacklist.length > 0) {
+            for (const blacklistedAddress of campaign.campaignParameters.blacklist) {
+                blacklistedLiquidityCalls.push(createCall(typeInfo.tokenAddress, "balanceOf", type, blacklistedAddress));
+            }
+        }
+        return blacklistedLiquidityCalls;
+    }
+    decodeListedSupply(index, decimals, list, calls) {
+        if (list.length === 0) {
+            return "0";
+        }
+        let listedSupply = 0;
+        for (const _ of list) {
+            listedSupply += BN2Number(decodeCall(calls, index++, "balanceOf"), decimals);
+        }
+        return listedSupply.toString();
+    }
+    decodeRound(round, index, calls, type, data) {
+        round.map(({ key, call, optional }) => {
+            if (optional) {
+                try {
+                    const value = decodeCall(calls, index, call, type);
+                    index++;
+                    data[key] = value;
+                }
+                catch {
+                    index++;
+                }
+            }
+            else {
+                const value = decodeCall(calls, index, call, type);
+                index++;
+                data[key] = value;
+            }
+        });
+    }
+    decodePreviousRound(round, calls, data, type, index) {
+        if (round === Round.one) {
+            this.decodeRound(this.rounds.round1, index, calls, type, data);
+        }
+        if (round === Round.two) {
+            this.decodeRound(this.rounds.round2, index, calls, type, data);
+        }
+        if (round === Round.three) {
+            this.decodeRound(this.rounds.round3, index, calls, type, data);
+        }
+        if (round === Round.four) {
+            this.decodeRound(this.rounds.round4, index, calls, type, data);
+        }
+    }
+    decodePreviousStakingRound(round, calls, data, type, index) {
+        if (round === Round.one) {
+            this.decodeRound(this.stakingRounds.round1, index, calls, type, data);
+        }
+        if (round === Round.two) {
+            this.decodeRound(this.stakingRounds.round2, index, calls, type, data);
+        }
+        if (round === Round.three) {
+            this.decodeRound(this.stakingRounds.round3, index, calls, type, data);
+        }
+        if (round === Round.four) {
+            this.decodeRound(this.stakingRounds.round4, index, calls, type, data);
+        }
+    }
+    encodeRound(round, callInfo, type) {
+        return round
+            .map(({ call, target, metaData, optional }) => {
+            if (optional && !callInfo[target]) {
+                return [];
+            }
+            if (metaData) {
+                return createCall(callInfo[target], call, type, callInfo[metaData]);
+            }
+            return createCall(callInfo[target], call, type);
+        })
+            .filter(call => Array.isArray(call) === false);
+    }
+    encodeNextRound(round, type, data) {
+        const keys = Object.keys(data);
+        const callInfo = keys.reduce((acc, key) => {
+            if (data[key]) {
+                acc[key] = data[key];
+            }
+            return acc;
+        }, {});
+        let calls = [];
+        if (round === Round.one) {
+            calls = this.encodeRound(this.rounds.round1, callInfo, type);
+        }
+        if (round === Round.two) {
+            calls = this.encodeRound(this.rounds.round2, callInfo, type);
+        }
+        if (round === Round.three) {
+            calls = this.encodeRound(this.rounds.round3, callInfo, type);
+        }
+        if (round === Round.four) {
+            calls = this.encodeRound(this.rounds.round4, callInfo, type);
+        }
+        return calls;
+    }
+    encodeStakingNextRound(round, type, data) {
+        const keys = Object.keys(data);
+        const callInfo = keys.reduce((acc, key) => {
+            if (data[key]) {
+                acc[key] = data[key];
+            }
+            return acc;
+        }, {});
+        let calls = [];
+        if (round === Round.one) {
+            calls = this.encodeRound(this.stakingRounds.round1, callInfo, type);
+        }
+        if (round === Round.two) {
+            calls = this.encodeRound(this.stakingRounds.round2, callInfo, type);
+        }
+        if (round === Round.three) {
+            calls = this.encodeRound(this.stakingRounds.round3, callInfo, type);
+        }
+        if (round === Round.four) {
+            calls = this.encodeRound(this.stakingRounds.round4, callInfo, type);
+        }
+        return calls;
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/helpers/eulerVaultNames.d.ts

@@ -0,0 +1 @@
+export declare function fetchEulerVaultName(vaultAddress: string, chainId: number): Promise<string | null>;

package/dist/src/engine/erc20SubTypeProcessors/helpers/eulerVaultNames.js

@@ -0,0 +1,13 @@
+// https://splice-api-ad64cd01a25d.herokuapp.com/mode/markets?market=0x34cf9BF641bd5f34197060A3f3478a1f97f78f0a
+import axios from "axios";
+export async function fetchEulerVaultName(vaultAddress, chainId) {
+    const url = `https://raw.githubusercontent.com/euler-xyz/euler-labels/refs/heads/master/${chainId}/vaults.json`;
+    try {
+        const response = await axios.get(url);
+        const vaultName = response.data[vaultAddress].name;
+        return vaultName;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/helpers/factoryFinder.d.ts

@@ -0,0 +1,5 @@
+import { tokenType } from "./tokenType";
+export declare function getTypeFromFactoryAddress(address: string): tokenType;
+export declare const enzymeFundValueCalculatorRouterMapping: {
+    [address: string]: string;
+};

package/dist/src/engine/erc20SubTypeProcessors/helpers/factoryFinder.js

@@ -0,0 +1,41 @@
+import { tokenType } from "./tokenType";
+const factoryAddresses = {
+    "0x420DD381b31aEf6683db6B902084cB0FFECe40Da": tokenType.aerodrome, // Aerodrome Base Factory
+    "0x31832f2a97Fd20664D76Cc421207669b55CE4BC0": tokenType.velodrome, // Velodrome Mode Factory
+    "0xc9Fe0C63Af9A39402e8a5514f9c43Af0322b665F": tokenType.curve, // Curve Factory Fraxtal
+    "0xc6C09471Ee39C7E30a067952FcC89c8922f9Ab53": tokenType.curve, // Curve Optimism Factory
+    "0x98EE851a00abeE0d95D08cF4CA2BdCE32aeaAF7F": tokenType.curve, // Curve Mainnet Factory
+    "0x9e6d12097339ddd5402FDD39fc0Ef86Eec54AB39": tokenType.splice, // Splice Mode Factory
+    "0x49Afe3abCf66CF09Fab86cb1139D8811C8afe56F": tokenType.toros, // Toros Base Factory
+    "0xAf39606bec181887951Ab6912Ac7EA216Bd6E4B4": tokenType.akron, // Akron Arbitrum Factory
+    "0xC3DC853dD716bd5754f421ef94fdCbac3902ab32": tokenType.enzyme, // Enzyme ETH Factory
+    "0x2e25271297537B8124b8f883a92fFd95C4032733": tokenType.enzyme, // Enzyme Polygon Factory
+    "0x71f6b49ae1558357bBb5A6074f1143c46cBcA03d": tokenType.dragonswap, // DragonSwap SEI Factory
+    "0x40be1cBa6C5B47cDF9da7f963B6F761F4C60627D": tokenType.koi, // Silo Staking Factory
+    "0xFDa619b6d20975be80A10332cD39b9a4b0FAa8BB": tokenType.baseswap, // Poolside Factory
+    "0xa19C51D91891D3DF7C13Ed22a2f89d328A82950f": tokenType.fenix, // Fenix Factory
+    "0x3a76e377ED58c8731F9DF3A36155942438744Ce3": tokenType.zkswap, // ZKSwap Factory
+    "0x6fcf753f2C67b83f7B09746Bbc4FA0047b35D050": tokenType.pendle, // Pendle Factory
+    "0x35A338522a435D46f77Be32C70E215B813D0e3aC": tokenType.pendleYT, // Pendle YT Factory
+    "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73": tokenType.pancakeswap, // PancakeSwap Factory BNB
+    "0x70ee0A6DB4F5a2Dc4d9c0b57bE97B9987e75BAFD": tokenType.pendleYT, // Pendle YT Factory
+    "0xFD513630F697A9C1731F196185fb9ebA6eAAc20B": tokenType.cpmmGamma, // CPMMGAMMA Factory
+    "0x9Ad6C38BE94206cA50bb0d90783181662f0Cfa10": tokenType.traderJoe, // Trader Joe Factory
+    "0x5Ea9DD3b6f042A34Df818C6c1324BC5A7c61427a": tokenType.curve, // Curve Corn 2crypto Factory
+    "0xd7E72f3615aa65b92A4DBdC211E296a35512988B": tokenType.curveNPool, // Curve Corn Stableswap Factory
+    "0x7Ca46A636b02D4aBC66883D7FF164bDE506DC66a": tokenType.curveNPool, // Curve Corn 3crypto Factory
+    "0xbC0797015fcFc47d9C1856639CaE50D0e69FbEE8": tokenType.curveNPool, // Curve Arbitrum 3crypto Factory
+    "0xA5961898870943c68037F6848d2D866Ed2016bcB": tokenType.curveNPool, // Curve Base
+    "0xB255D6A720BB7c39fee173cE22113397119cB930": tokenType.katana, // Katana Ronin
+};
+export function getTypeFromFactoryAddress(address) {
+    if (factoryAddresses[address]) {
+        return factoryAddresses[address];
+    }
+    return tokenType.unknown;
+}
+// Mapping of dispatcher to fund value calculator for enzyme
+export const enzymeFundValueCalculatorRouterMapping = {
+    "0xC3DC853dD716bd5754f421ef94fdCbac3902ab32": "0x7c728cd0CfA92401E01A4849a01b57EE53F5b2b9", // ETH
+    "0x2e25271297537B8124b8f883a92fFd95C4032733": "0xD70389a7d6171e1DBA6C3df4DB7331811fd93f08", // Polygon
+};