@merkl/api 0.10.199 → 0.10.200

package/package.json

@@ -33,7 +33,7 @@
     "@elysiajs/cors": "^1.1.1",
     "@elysiajs/eden": "^1.1.3",
     "@elysiajs/opentelemetry": "^1.1.7",
-    "@elysiajs/swagger": "^0.7.4",
+    "@elysiajs/swagger": "^1.1.6",
     "@ethersproject/abi": "^5.7.0",
     "@google-cloud/storage": "^7.14.0",
     "@opentelemetry/auto-instrumentations-node": "^0.55.0",
@@ -51,7 +51,6 @@
     "commander": "^12.1.0",
     "crypto-js": "^4.2.0",
     "elysia": "1.1.26",
-    "elysia-autoroutes": "^0.5.0",
     "elysia-rate-limit": "^4.1.0",
     "ethers": "^5.7.2",
     "ethers-types": "3.17.0",
@@ -90,5 +89,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "v0.10.199"
+  "version": "v0.10.200"
 }

package/dist/src/libs/campaigns/campaignTypes/ERC20DynamicDataRefacto.d.ts

@@ -1,3 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-export declare function ERC20DynamicDataRefacto(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.ERC20>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.ERC20>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/ERC20DynamicDataRefacto.js

@@ -1,155 +0,0 @@
-import { merklChainDataWithCache } from "../../merklChainData";
-import { BN2Number, BalancerPoolInterface, ERC20Interface, EnzymeInterface, FactoryInterface, MetamorphoInterface, YEAR, } from "@sdk";
-import { batchMulticallCallWithRetry } from "../../../utils/generic";
-import { Pricer } from "../../../utils/pricer";
-import { getLastEligibilityRatio } from "../utils/getLastEligibilityRatio";
-import { tokenType } from "./ERC20SubTypes/helpers/tokenType";
-import { getTokenPricesInfo } from "./ERC20SubTypes/subtypesPricesRefactoFinal";
-import { getTokenTypeRound1 } from "./ERC20SubTypes/subtypesRound1RefactoFinal";
-import { getTokenTypeRound2 } from "./ERC20SubTypes/subtypesRound2RefactoFinal";
-import { getTokenTypeRound3 } from "./ERC20SubTypes/subtypesRound3RefactoFinal";
-import { getTokenTypeRound4 } from "./ERC20SubTypes/subtypesRound4RefactoFinal";
-export async function ERC20DynamicDataRefacto(chainId, campaigns) {
-    const pricer = await Pricer.load();
-    const currentRoot = (await merklChainDataWithCache(chainId)).merkleRoot;
-    // Round 1: Get the high level type for each token (will need to be refined lated with more calls)
-    const callsRounds1 = [];
-    for (const campaign of campaigns) {
-        // Keep this commented, only use for tests
-        // if (campaign.campaignId === "0xf09492c6d3bd475e269e9f90c92d7e11a671a8fc43470b424ccbb0eea67b762e") {
-        //   // Filament test
-        //   campaign.campaignParameters.targetToken = "0xe855B8018C22A05F84724e93693caf166912aDD5";
-        // }
-        if ([
-            "0xb9bf1ace04e702363bd76b5828ca64a00984af9118672be96c1c200943da941f",
-            "0x1ad188dd597199ca8e6d6a01d5af362769f46bb749da5c08d27eaec4397f53b5",
-        ].includes(campaign.campaignId)) {
-            campaign.campaignParameters.url = "https://moonwell.fi/markets/supply/base/usdc";
-        }
-        if (campaign.campaignId === "0xb656fa534c487d3d7c94a5ac2c265acde0d5b7a7c562548c58cfcbf4f7f552f4") {
-            campaign.campaignParameters.url = "https://app.indexcoop.com/swap/eth/hyeth";
-        }
-        callsRounds1.push({
-            allowFailure: true,
-            callData: FactoryInterface.encodeFunctionData("factory"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: true,
-            callData: MetamorphoInterface.encodeFunctionData("MORPHO"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("name"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: true,
-            callData: BalancerPoolInterface.encodeFunctionData("getPoolId"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: true,
-            callData: EnzymeInterface.encodeFunctionData("getCreator"),
-            target: campaign.campaignParameters.targetToken,
-        });
-    }
-    const resultRound1 = await batchMulticallCallWithRetry(chainId, {
-        calls: callsRounds1,
-    });
-    const tokenTypesByCampaign = {};
-    // Round 2: Decode result from round 1 and get some additional info for the types before the final calls
-    const callsRounds2 = [];
-    let i = 0;
-    for (const campaign of campaigns) {
-        let typeStruct = {
-            type: tokenType.unknown,
-            calls: [],
-            typeInfo: {},
-        };
-        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i, campaign);
-        i += 5;
-        tokenTypesByCampaign[campaign.campaignId] = typeStruct;
-        callsRounds2.push(...typeStruct.calls);
-    }
-    const resultRound2 = await batchMulticallCallWithRetry(chainId, {
-        calls: callsRounds2,
-    });
-    // Round 3: Decode result from round 2 and get some additional info for the types before the final calls
-    const callsRounds3 = [];
-    let j = 0;
-    for (const campaign of campaigns) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
-        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound2(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultRound2);
-        j += callsForCampaign;
-        callsRounds3.push(...tokenTypesByCampaign[campaign.campaignId].calls);
-    }
-    const resultRound3 = await batchMulticallCallWithRetry(chainId, {
-        calls: callsRounds3,
-    });
-    // Final round before execute
-    let callsFinal = [];
-    j = 0;
-    for (const campaign of campaigns) {
-        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
-        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound3(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultRound3);
-        j += callsForCampaign;
-        callsFinal = callsFinal.concat(tokenTypesByCampaign[campaign.campaignId].calls);
-    }
-    // Round 4: Get the final data
-    const resultsFinal = await batchMulticallCallWithRetry(chainId, {
-        calls: callsFinal,
-    });
-    j = 0;
-    let calls = [];
-    for (const campaign of campaigns) {
-        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
-        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound4(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultsFinal, campaign);
-        j += callsForCampaign;
-        calls = calls.concat(tokenTypesByCampaign[campaign.campaignId].calls);
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                let i = 0;
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    const priceRewardToken = (await pricer.get({
-                        address: campaign.rewardToken,
-                        chainId,
-                        symbol: campaign.campaignParameters.symbolRewardToken,
-                    })) ?? 0;
-                    // Get the data from the final round and process it to get the price of the target token and some extra info
-                    const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
-                    tokenTypesByCampaign[campaign.campaignId] = await getTokenPricesInfo(i, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, result, campaign, pricer);
-                    i += callsForCampaign;
-                    const whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
-                    const totalSupplyTargetToken = whitelistedSupplyTargetToken;
-                    const priceTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
-                    let lastEligibilityRatio = 1;
-                    if (!!campaign.campaignParameters.hooks?.length) {
-                        lastEligibilityRatio = await getLastEligibilityRatio(campaign, chainId, currentRoot, []);
-                    }
-                    dynamicData.push({
-                        ...campaign,
-                        apr: (lastEligibilityRatio *
-                            (priceRewardToken *
-                                BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                                YEAR *
-                                100)) /
-                            campaign.campaignParameters.duration /
-                            (whitelistedSupplyTargetToken * priceTargetToken),
-                        totalSupplyTargetToken,
-                        tvl: whitelistedSupplyTargetToken * priceTargetToken,
-                        type: tokenTypesByCampaign[campaign.campaignId].type,
-                        typeInfo: tokenTypesByCampaign[campaign.campaignId].typeInfo,
-                        priceRewardToken: priceRewardToken,
-                        lastEligibilityRatio,
-                    });
-                }
-                return dynamicData;
-            },
-        },
-    };
-}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesPricesRefactoFinal.d.ts

@@ -1,4 +0,0 @@
-import type { Pricer } from "../../../../utils/pricer";
-import type { Campaign, CampaignParameters } from "@sdk";
-import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenPricesInfo(index: number, type: tokenType, typeInfo: any, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesPricesRefactoFinal.js

@@ -1,24 +0,0 @@
-import { tokenType } from "./helpers/tokenType";
-import { processorMapping } from "./processor/processorMapping";
-export async function getTokenPricesInfo(index, type, typeInfo, calls, campaign, pricer) {
-    const ProcessorClass = processorMapping[type];
-    try {
-        if (!ProcessorClass) {
-            throw new Error(`Processor not found for key: ${type}`);
-        }
-        const processorObject = new ProcessorClass();
-        return processorObject.computeRound5(index, type, typeInfo, calls, campaign, pricer);
-    }
-    catch (error) {
-        console.error(error);
-        return {
-            type: tokenType.unknown,
-            calls: [],
-            typeInfo: {
-                totalSupply: 0,
-                blacklistedSupply: 0,
-                priceTargetToken: 0,
-            },
-        };
-    }
-}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1RefactoFinal.d.ts

@@ -1,4 +0,0 @@
-import type { Campaign, CampaignParameters } from "@sdk";
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
-import { type tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1RefactoFinal.js

@@ -1,230 +0,0 @@
-import { decodeCall } from "../../../../utils/decodeCalls";
-import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
-import { tokenType } from "./helpers/tokenType";
-import { processorMapping } from "./processor/processorMapping";
-function satisfiesNameConditions(name, type) {
-    const lowerCaseName = name.toLowerCase();
-    switch (type) {
-        case tokenType.fraxlend:
-            return lowerCaseName.includes("fraxlend interest bearing");
-        case tokenType.sturdy_aggregator:
-            return lowerCaseName.includes("aggregator");
-        case tokenType.sturdy_silo:
-            return lowerCaseName.includes("sturdy interest bearing");
-        case tokenType.aura:
-            return lowerCaseName.includes("aura deposit vault");
-        case tokenType.poolside:
-            return lowerCaseName.includes("poolside");
-        case tokenType.balancerGauge:
-            return lowerCaseName.includes("balancer") && !lowerCaseName.includes("aura deposit vault");
-        case tokenType.gearbox:
-            return lowerCaseName.includes("farming of");
-        case tokenType.euler_borrow:
-            return lowerCaseName.startsWith("debt token of evk vault");
-        case tokenType.euler_lend:
-            return lowerCaseName.includes("evk vault");
-        case tokenType.fluid:
-            return lowerCaseName.startsWith("fluid");
-        case tokenType.filament:
-            return lowerCaseName.startsWith("filament");
-        case tokenType.radiant_lend:
-            return lowerCaseName.includes("radiant interest");
-        case tokenType.radiant_borrow:
-            return lowerCaseName.includes("radiant variable debt");
-        case tokenType.ionic:
-            return lowerCaseName.includes("ionic");
-        case tokenType.rfx:
-            return lowerCaseName.includes("rfx");
-        case tokenType.layerbank:
-            return lowerCaseName.includes("layerbank");
-        case tokenType.moonwell:
-            return lowerCaseName.includes("moonwell");
-        case tokenType.curve_2:
-            return (lowerCaseName === "crvusd/frax" ||
-                lowerCaseName === "ezeth/wfrxeth" ||
-                lowerCaseName === "pufeth/wsteth" ||
-                lowerCaseName === "hai/lusd");
-        case tokenType.silostaking:
-            return lowerCaseName === "isei";
-        case tokenType.beefy:
-            return lowerCaseName.startsWith("moo velo");
-        case tokenType.uniswapv2:
-            return lowerCaseName.includes("uniswap");
-        case tokenType.fenix:
-            return lowerCaseName.includes("stablev1 amm");
-        case tokenType.ra:
-            return lowerCaseName.includes("volatile pair -") || lowerCaseName.includes("correlated pair -");
-        case tokenType.syncswap:
-            return lowerCaseName.includes("syncswap");
-        case tokenType.aave_lending:
-            return lowerCaseName.includes("aave");
-        case tokenType.aave_borrowing:
-            return lowerCaseName.includes("aave") && lowerCaseName.includes("debt");
-        case tokenType.yei_borrowing:
-            return ((lowerCaseName.startsWith("yei") || (lowerCaseName.includes("aave") && lowerCaseName.includes("yei"))) &&
-                lowerCaseName.includes("debt"));
-        case tokenType.ironclad_borrowing:
-            return ((lowerCaseName.startsWith("ironclad") ||
-                (lowerCaseName.includes("aave") && lowerCaseName.includes("ironclad"))) &&
-                lowerCaseName.includes("debt") &&
-                name.toLowerCase() !== "ironclad token");
-        case tokenType.zerolend_borrowing:
-            return lowerCaseName.includes("zerolend") && lowerCaseName.includes("debt");
-        case tokenType.yei_lending:
-            return lowerCaseName.startsWith("yei") || (lowerCaseName.includes("aave") && lowerCaseName.includes("yei"));
-        case tokenType.ironclad_lending:
-            return ((lowerCaseName.startsWith("ironclad") ||
-                (lowerCaseName.includes("aave") && lowerCaseName.includes("ironclad"))) &&
-                name.toLowerCase() !== "ironclad token");
-        case tokenType.zerolend_lending:
-            return lowerCaseName.includes("zerolend");
-        case tokenType.compound:
-            return lowerCaseName.includes("compound");
-        case tokenType.ironcladStaking:
-            return lowerCaseName === "ironclad token";
-        case tokenType.woofi:
-            return lowerCaseName.includes("woofi");
-        case tokenType.maverickBoostedPosition:
-            return lowerCaseName.includes("maverick");
-        case tokenType.zkSwapThreePool:
-            return lowerCaseName.includes("zf");
-        case tokenType.maha:
-            return lowerCaseName.includes("staked") && lowerCaseName.includes("maha");
-        case tokenType.tempest:
-            return lowerCaseName.startsWith("ts");
-        case tokenType.tempestStaking:
-            return lowerCaseName.startsWith("tempest");
-        case tokenType.holdstation:
-            return lowerCaseName.startsWith("hs");
-        default:
-            return false;
-    }
-}
-function generateResult(type, name, targetToken, typeInfo) {
-    const ProcessorClass = processorMapping[type];
-    if (!ProcessorClass) {
-        throw new Error(`Processor not found for key: ${type}`);
-    }
-    const processorObject = new ProcessorClass();
-    typeInfo = {
-        ...typeInfo,
-        name: name,
-        tokenAddress: targetToken,
-        totalSupply: 0,
-        blacklistedSupply: 0,
-    };
-    return processorObject.computeRound1(type, typeInfo);
-}
-function processNamingConditions(type, name, targetToken) {
-    if (satisfiesNameConditions(name, type)) {
-        return generateResult(type, name, targetToken, {});
-    }
-}
-function processNamingConditionsInOrder(types, name, targetToken) {
-    for (const type of types) {
-        const result = processNamingConditions(type, name, targetToken);
-        if (result)
-            return result;
-    }
-}
-function parseForFactory(calls, index, targetToken) {
-    try {
-        const factory = decodeCall(calls, index, "factory");
-        const name = decodeCall(calls, index + 2, "name");
-        const type = getTypeFromFactoryAddress(factory);
-        if (type !== tokenType.unknown)
-            return generateResult(type, name, targetToken, { factory });
-    }
-    catch (e) {
-        // No factory on this token
-    }
-}
-function parseForEnzyme(calls, index, targetToken) {
-    // Enzyme check
-    try {
-        const dispatcher = decodeCall(calls, index + 4, "getCreator");
-        const name = decodeCall(calls, index + 2, "name");
-        const type = getTypeFromFactoryAddress(dispatcher);
-        const fundValueCalculator = enzymeFundValueCalculatorRouterMapping[dispatcher];
-        const typeInfo = {
-            fundValueCalculator,
-            dispatcher,
-        };
-        if (type === tokenType.enzyme) {
-            return generateResult(type, name, targetToken, typeInfo);
-        }
-    }
-    catch (e) {
-        // No factory on this token
-    }
-}
-function parseForMetamorpho(calls, index, targetToken) {
-    // MetaMorpho check
-    try {
-        decodeCall(calls, index + 1, "MORPHO");
-        const name = decodeCall(calls, index + 2, "name");
-        return generateResult(tokenType.metamorpho, name, targetToken, {});
-    }
-    catch (e) {
-        // Not a metamorpho token
-    }
-}
-function parseForBalancer(calls, index, targetToken, name) {
-    // Check for balancer pools
-    try {
-        decodeCall(calls, index + 3, "getPoolId");
-        return generateResult(tokenType.balancerPool, name, targetToken, {});
-    }
-    catch (e) {
-        // Not a balancer pool
-    }
-}
-function parseForStaking(campaign, calls, index, targetToken) {
-    try {
-        const whitelist = campaign.campaignParameters.whitelist;
-        if (whitelist.length === 1) {
-            const forwarders = campaign.campaignParameters.forwarders;
-            if (forwarders.length === 1) {
-                if (forwarders[0].sender === whitelist[0]) {
-                    const name = decodeCall(calls, index + 2, "name");
-                    return generateResult(tokenType.staking, name, targetToken, { stakingContract: whitelist[0] });
-                }
-            }
-        }
-    }
-    catch (e) {
-        // No factory on this token
-        // console.log(e);
-    }
-}
-export function getTokenTypeRound1(calls, targetToken, index, campaign) {
-    const returnValueOfCalls = calls.map(call => call.returnData);
-    let result = parseForFactory(returnValueOfCalls, index, targetToken);
-    if (result)
-        return result;
-    result = parseForEnzyme(returnValueOfCalls, index, targetToken);
-    if (result)
-        return result;
-    result = parseForMetamorpho(returnValueOfCalls, index, targetToken);
-    if (result)
-        return result;
-    result = parseForStaking(campaign, returnValueOfCalls, index, targetToken);
-    if (result)
-        return result;
-    let name;
-    try {
-        name = decodeCall(returnValueOfCalls, index + 2, "name");
-    }
-    catch (e) {
-        return generateResult(tokenType.unknown, "Unknown", targetToken, {});
-    }
-    result = parseForBalancer(returnValueOfCalls, index, targetToken, name);
-    if (result)
-        return result;
-    // Order matters
-    const ordered_token_Type = Object.values(tokenType).filter(value => typeof value === "string");
-    result = processNamingConditionsInOrder(ordered_token_Type, name, targetToken);
-    if (result)
-        return result;
-    return generateResult(tokenType.unknown, name, targetToken, {});
-}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound2RefactoFinal.d.ts

@@ -1,3 +0,0 @@
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
-import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound2RefactoFinal.js

@@ -1,22 +0,0 @@
-import { processorMapping } from "./processor/processorMapping";
-export function getTokenTypeRound2(index, type, typeInfo, calls) {
-    try {
-        const returnValueOfCalls = calls.map(call => call.returnData);
-        const ProcessorClass = processorMapping[type];
-        if (!ProcessorClass) {
-            throw new Error(`Processor not found for key: ${type}`);
-        }
-        const processorObject = new ProcessorClass();
-        return processorObject.computeRound2(index, type, typeInfo, returnValueOfCalls);
-    }
-    catch (error) {
-        console.error(error);
-        return {
-            type: type,
-            calls: [],
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound3RefactoFinal.d.ts

@@ -1,3 +0,0 @@
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
-import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound3(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound3RefactoFinal.js

@@ -1,22 +0,0 @@
-import { processorMapping } from "./processor/processorMapping";
-export function getTokenTypeRound3(index, type, typeInfo, calls) {
-    try {
-        const ProcessorClass = processorMapping[type];
-        const returnValueOfCalls = calls.map(call => call.returnData);
-        if (!ProcessorClass) {
-            throw new Error(`Processor not found for key: ${type}`);
-        }
-        const processorObject = new ProcessorClass();
-        return processorObject.computeRound3(index, type, typeInfo, returnValueOfCalls);
-    }
-    catch (error) {
-        console.error(error);
-        return {
-            type: type,
-            calls: [],
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound4RefactoFinal.d.ts

@@ -1,4 +0,0 @@
-import type { Campaign, CampaignParameters } from "@sdk";
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
-import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound4(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound4RefactoFinal.js

@@ -1,22 +0,0 @@
-import { processorMapping } from "./processor/processorMapping";
-export function getTokenTypeRound4(index, type, typeInfo, calls, campaign) {
-    try {
-        const ProcessorClass = processorMapping[type];
-        const returnValueOfCalls = calls.map(call => call.returnData);
-        if (!ProcessorClass) {
-            throw new Error(`Processor not found for key: ${type}`);
-        }
-        const processorObject = new ProcessorClass();
-        return processorObject.computeRound4(index, type, typeInfo, returnValueOfCalls, campaign);
-    }
-    catch (error) {
-        console.error(error);
-        return {
-            type: type,
-            calls: [],
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-}

package/dist/src/libs/campaigns/campaignsDynamicDataRefacto.d.ts

@@ -1,3 +0,0 @@
-import { Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../utils/execute";
-export declare function campaignsDynamicDataRefacto<T extends Campaign>(chainId: MerklChainId, campaigns: CampaignParameters<T>[], type: T, nextVersion?: boolean): Promise<UncachedResult<Partial<CampaignDynamicData<T>[]>>>;

package/dist/src/libs/campaigns/campaignsDynamicDataRefacto.js

@@ -1,75 +0,0 @@
-import { engineDbClient } from "../../utils/prisma";
-import { Campaign } from "@sdk";
-import { getAddress } from "ethers/lib/utils";
-import { AjnaDynamicData } from "./campaignTypes/AjnaDynamicData";
-import { BadgerDynamicData } from "./campaignTypes/BadgerDynamicData";
-import { CLAMMDynamicData } from "./campaignTypes/CLAMMDynamicData";
-import { CompoundDynamicData } from "./campaignTypes/CompoundDynamicData";
-import { DolomiteDynamicData } from "./campaignTypes/DolomiteDynamicData";
-import { ERC20DynamicDataRefacto } from "./campaignTypes/ERC20DynamicDataRefacto";
-import { ERC20_SNAPSHOTDynamicData } from "./campaignTypes/ERC20_SNAPSHOTDynamicData";
-import { EulerDynamicData } from "./campaignTypes/EulerDynamicData";
-import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData";
-import { MORPHODynamicData } from "./campaignTypes/MORPHODynamicData";
-import { RadiantDynamicData } from "./campaignTypes/RadiantDynamicData";
-import { SILODynamicData } from "./campaignTypes/SILODynamicData";
-export async function campaignsDynamicDataRefacto(chainId, campaigns, type, nextVersion = false) {
-    try {
-        const tags = (await engineDbClient.campaignCreators.findMany()).reduce((acc, curr) => {
-            acc[getAddress(curr.address)] = curr.tags.split(",");
-            return acc;
-        }, {});
-        for (const campaign of campaigns) {
-            campaign.tags = tags[getAddress(campaign.creator)] || [];
-        }
-    }
-    catch (e) { }
-    switch (type) {
-        case Campaign.ERC20: {
-            return ERC20DynamicDataRefacto(chainId, campaigns);
-        }
-        case Campaign.CLAMM: {
-            return CLAMMDynamicData(chainId, campaigns);
-        }
-        case Campaign.ERC20_SNAPSHOT: {
-            return ERC20_SNAPSHOTDynamicData(chainId, campaigns);
-        }
-        case Campaign.JSON_AIRDROP: {
-            return JSON_AIRDROPDynamicData(chainId, campaigns);
-        }
-        case Campaign.SILO: {
-            return SILODynamicData(chainId, campaigns);
-        }
-        case Campaign.RADIANT: {
-            return RadiantDynamicData(chainId, campaigns);
-        }
-        case Campaign.MORPHO: {
-            return MORPHODynamicData(chainId, campaigns);
-        }
-        case Campaign.EULER: {
-            return EulerDynamicData(chainId, campaigns);
-        }
-        case Campaign.DOLOMITE: {
-            return DolomiteDynamicData(chainId, campaigns);
-        }
-        case Campaign.BADGER: {
-            return BadgerDynamicData(chainId, campaigns);
-        }
-        case Campaign.AJNA: {
-            return AjnaDynamicData(chainId, campaigns);
-        }
-        case Campaign.COMPOUND: {
-            return CompoundDynamicData(chainId, campaigns);
-        }
-    }
-    return {
-        cached: false,
-        call: {
-            callData: [],
-            handler: () => { },
-            reducer: async (_) => {
-                return campaigns;
-            },
-        },
-    };
-}