@merkl/api 0.21.47 → 1.0.0

package/dist/src/engine/implementations/Morpho/metadata.js

@@ -1,63 +0,0 @@
-import { OpportunityAction } from "@db/api";
-import { BN2Number, ChainId, MorphoSubCampaignType, NETWORK_LABELS, } from "@sdk";
-import { getAddress } from "viem";
-export class MorphoMetadata {
-    async build(campaign) {
-        let { params, computeChainId, subType } = campaign;
-        if (!subType)
-            subType = 0;
-        const morphoParams = params;
-        const market = `${morphoParams.symbolLoanToken}/${morphoParams.symbolBorrowToken} ${morphoParams?.LLTV && BN2Number(morphoParams?.LLTV, 16)}%`;
-        const subtypes = [
-            { name: `Deposit in ${morphoParams.nameTargetToken} - Metamorpho`, action: OpportunityAction.LEND },
-            { name: `Supply ${morphoParams.symbolLoanToken} on ${market}`, action: OpportunityAction.LEND },
-            { name: `Borrow ${morphoParams.symbolLoanToken} on ${market}`, action: OpportunityAction.BORROW },
-            { name: `Lend ${morphoParams.symbolBorrowToken} on ${market}`, action: OpportunityAction.LEND },
-        ];
-        const subtype = subtypes[subType];
-        const tokens = [{ chainId: computeChainId, address: params.targetToken }];
-        if (subType === MorphoSubCampaignType.META) {
-            const typedParams = params;
-            tokens.push({ chainId: computeChainId, address: typedParams.underlyingToken });
-        }
-        return {
-            action: subtype.action,
-            tokens,
-            name: subtype.name,
-            mainProtocol: (computeChainId === ChainId.POLYGON ? "compound" : "morpho"),
-            depositUrl: MorphoMetadata.generateUrl(computeChainId, params, morphoParams, subType),
-            explorerAddress: getAddress(params.targetToken),
-        };
-    }
-    static generateUrl(computeChainId, params, _morphoParams, subType) {
-        // Compound blue
-        if (computeChainId === ChainId.POLYGON) {
-            switch (subType) {
-                case MorphoSubCampaignType.META: {
-                    return `https://www.compound.blue/${params.targetToken.toLowerCase()}`;
-                }
-                case MorphoSubCampaignType.SUPPLY_BLUE: {
-                    return `https://www.compound.blue/${params.targetToken.toLowerCase()}`;
-                }
-                case MorphoSubCampaignType.BORROWING_BLUE:
-                case MorphoSubCampaignType.COLLATERAL_BLUE: {
-                    const typedParams = params;
-                    return `https://www.compound.blue/borrow/${typedParams.marketId.toLowerCase()}`;
-                }
-            }
-        }
-        switch (subType) {
-            case MorphoSubCampaignType.META: {
-                return `https://app.morpho.org/vault?vault=${params.targetToken}&network=${NETWORK_LABELS[computeChainId]?.toLowerCase()}`;
-            }
-            case MorphoSubCampaignType.SUPPLY_BLUE: {
-                return `https://app.morpho.org/?network=${NETWORK_LABELS[computeChainId]?.toLowerCase()}`;
-            }
-            case MorphoSubCampaignType.BORROWING_BLUE:
-            case MorphoSubCampaignType.COLLATERAL_BLUE: {
-                const typedParams = params;
-                return `https://app.morpho.org/market?id=${typedParams.marketId}&network=${NETWORK_LABELS[computeChainId]?.toLowerCase()}`;
-            }
-        }
-    }
-}

package/dist/src/engine/implementations/MultiLog/metadata.js

@@ -1,36 +0,0 @@
-import { ComposedType } from "@sdk";
-import { metadataBuilderFactory } from "@/engine/metadata/factory";
-export class MultiLogMetaData {
-    async build(campaign) {
-        const mainComposed = campaign.params.composedCampaigns.find(composedCampaign => composedCampaign.composedType === ComposedType.MAIN);
-        if (!mainComposed) {
-            throw new Error("Main composed campaign not found");
-        }
-        const mainComposedComplete = {
-            ...mainComposed,
-            id: campaign.id,
-            campaignType: mainComposed.campaignType,
-            campaignSubType: mainComposed.campaignSubType,
-            distributionChainId: campaign.distributionChainId,
-            type: "",
-            distributionType: campaign.distributionType,
-            subType: null,
-            params: mainComposed.campaignParameters,
-            computeChainId: mainComposed.computeChainId,
-            creator: {
-                address: "",
-                tags: [],
-                creatorId: null,
-            },
-            creatorAddress: campaign.creatorAddress,
-            createdAt: campaign.createdAt,
-            chain: {
-                id: 0,
-                name: "",
-                icon: "",
-            },
-            rewardToken: campaign.rewardToken,
-        };
-        return await metadataBuilderFactory(mainComposed.campaignType).build(mainComposedComplete, "");
-    }
-}

package/dist/src/engine/implementations/MultiLog/tvl.js

@@ -1,59 +0,0 @@
-import { DynamicDataService } from "@/modules/v4/dynamicData/dynamicData.service";
-import { TvlType } from "@db/api";
-import { ComposedType } from "@sdk";
-import { all, create } from "mathjs";
-export class MultiLogTVLBuilder {
-    async build(_computeChainId, campaigns) {
-        const tvls = [];
-        for (const campaign of campaigns) {
-            const mainComposedList = campaign.campaignParameters.composedCampaigns.filter(composedCampaign => composedCampaign.composedType === ComposedType.MAIN);
-            if (mainComposedList.length === 0) {
-                throw new Error("Main composed campaign not found");
-            }
-            if (mainComposedList.length > 1) {
-                // TODO: handle multiple main composed campaigns
-                const tvlMapping = {};
-                const multipliers = {};
-                const tvlBreakdown = [];
-                for (const composedCampaign of mainComposedList) {
-                    const composedCampaignTVL = (await DynamicDataService.update(composedCampaign.computeChainId, composedCampaign.campaignType, [composedCampaign], true))[0];
-                    const tvlValue = typeof composedCampaignTVL.tvl === "string"
-                        ? Number(composedCampaignTVL.tvl)
-                        : composedCampaignTVL.tvl.total;
-                    tvlMapping[composedCampaign.composedIndex] = tvlValue;
-                    multipliers[composedCampaign.composedIndex] = Number(composedCampaign.composedMultiplier ?? 10 ** 9);
-                    tvlBreakdown.push({
-                        identifier: composedCampaign.campaignId,
-                        type: TvlType.PROTOCOL,
-                        value: Math.abs(tvlValue),
-                    });
-                }
-                const config = {
-                    number: "bigint",
-                };
-                const bigmath = create(all, config);
-                const scope = { tvlMapping, multipliers, BASE_9: Number(10 ** 9) };
-                const computeExpression = campaign.campaignParameters.composedCampaignsCompute.replace(/\d+/g, match => {
-                    return tvlMapping[match] !== undefined ? `tvlMapping["${match}"] * multipliers["${match}"] / BASE_9` : "0";
-                });
-                const totalTvl = bigmath.evaluate(computeExpression, scope);
-                tvls.push({
-                    campaign: campaign,
-                    tvl: totalTvl,
-                    tvlBreakdown,
-                });
-                continue;
-            }
-            const mainComposed = mainComposedList[0];
-            if (mainComposed) {
-                const mainCampaignTVL = (await DynamicDataService.update(mainComposed.computeChainId, mainComposed.campaignType, [mainComposed], true))[0];
-                tvls.push({
-                    campaign: campaign,
-                    tvl: typeof mainCampaignTVL.tvl === "string" ? Number(mainCampaignTVL.tvl) : mainCampaignTVL.tvl.total,
-                    tvlBreakdown: [],
-                });
-            }
-        }
-        return tvls;
-    }
-}

package/dist/src/engine/implementations/Radiant/metadata.js

@@ -1,33 +0,0 @@
-import { log } from "@/utils/logger";
-import { OpportunityAction } from "@db/api";
-import { ChainInteractionService, NETWORK_LABELS, RadiantInterface, } from "@sdk";
-import { getAddress } from "viem";
-export class RadiantMetadata {
-    async build(campaign) {
-        let { params, computeChainId, subType } = campaign;
-        if (!subType)
-            subType = 0;
-        const tokens = [{ chainId: computeChainId, address: params.targetToken }];
-        try {
-            const result = await ChainInteractionService(computeChainId).fetchState([
-                {
-                    target: params.targetToken,
-                    allowFailure: true,
-                    callData: RadiantInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
-                },
-            ]);
-            const underlyingAddress = getAddress(RadiantInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", result[0].returnData)[0]);
-            tokens.push({ chainId: computeChainId, address: underlyingAddress });
-        }
-        catch {
-            log.warn(`failed to fetch underlying asset address on ${NETWORK_LABELS[computeChainId]} for radiant token ${params.targetToken}`);
-        }
-        return {
-            action: subType <= 1 ? OpportunityAction.LEND : OpportunityAction.BORROW,
-            name: [subType <= 1 ? "Lend" : "Borrow", params.symbolTargetToken].join(" "),
-            tokens,
-            mainProtocol: "radiant",
-            explorerAddress: getAddress(params.targetToken),
-        };
-    }
-}

package/dist/src/engine/implementations/Silo/metadata.js

@@ -1,20 +0,0 @@
-import { OpportunityAction } from "@db/api";
-import { getAddress } from "viem";
-export class SiloMetadata {
-    async build(campaign) {
-        let { params, computeChainId, subType } = campaign;
-        if (!subType)
-            subType = 0;
-        let suffix = ["Deposit", "Protected Deposit", "Debt"][subType];
-        const assetSymbol = params.symbolTargetToken;
-        if (params.forwarders.length === 1 && assetSymbol)
-            suffix += ` (${assetSymbol} Market)`;
-        return {
-            action: subType <= 1 ? OpportunityAction.LEND : OpportunityAction.BORROW,
-            name: [subType <= 1 ? "Lend" : "Borrow", params.symbolTargetToken, suffix].join(" "),
-            tokens: [{ chainId: computeChainId, address: params.targetToken }],
-            mainProtocol: "silo",
-            explorerAddress: getAddress(params.targetToken),
-        };
-    }
-}

package/dist/src/engine/implementations/UniswapV4/metadata.js

@@ -1,36 +0,0 @@
-import { sanitizeChainName } from "@/utils/sanitizeChain";
-import { OpportunityAction } from "@db/api";
-import { getAddress } from "viem";
-export class UniswapV4Metadata {
-    async build(campaign) {
-        const { params, computeChainId } = campaign;
-        const whitelistNameString = "";
-        //   if (params.whitelist.length > 0) {
-        //     for (const whitelist of params.whitelist) {
-        //       if (whitelistNameString.length > 0) {
-        //         whitelistNameString += "or";
-        //       }
-        //       const forwarder = params.forwarders.find(x => getAddress(x.sender) === getAddress(whitelist));
-        //       const forwarderType = (forwarder as CLAMMForwarder)?.type;
-        //       const forwarderName = !!forwarderType ? almName(forwarderType) : null;
-        //       if (!!forwarderName) {
-        //         whitelistNameString += ` ${forwarderName} `;
-        //       }
-        //     }
-        //   }
-        return {
-            name: `Provide liquidity to ${whitelistNameString} UniswapV4 ${params.symbolCurrency0}-${params.symbolCurrency1}${params.lpFee ? ` ${params.lpFee / 10_000}%` : ""}`,
-            action: OpportunityAction.POOL,
-            tokens: [
-                { chainId: computeChainId, address: params.currency0 },
-                { chainId: computeChainId, address: params.currency1 },
-            ],
-            mainProtocol: "uniswap",
-            explorerAddress: getAddress(params.poolManager),
-            depositUrl: UniswapV4Metadata.generateUrl(computeChainId, params),
-        };
-    }
-    static generateUrl(computeChainId, params) {
-        return `https://app.uniswap.org/explore/pools/${sanitizeChainName(computeChainId)}/${params.poolId}`;
-    }
-}

package/dist/src/engine/implementations/UniswapV4/tvl.js

@@ -1,158 +0,0 @@
-import { BucketService } from "@/modules/v4/bucket/bucket.service";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { engineDbClient } from "@db";
-import { TvlType } from "@db/api";
-import { BN2Number, ChainInteractionService, NETWORK_LABELS, UniswapV4Addresses, UniswapV4StateViewInterface, getRawPriceFromSqrtRatioX96, getSqrtRatioAtTick, } from "@sdk";
-/**
- * Compute TVL
- * @dev important: using the most recent state save with current prices
- *      it's only an estimate
- */
-async function computeUniV4PoolTVLFromMostRecentStateSave(computeChainId, poolID, campaign) {
-    let stateSave;
-    let blockNumber;
-    let states = {};
-    // TEMPORARY: handle Gamma TVL
-    const nodesTVL = {};
-    const currentBlock = await ChainInteractionService(computeChainId).getBlockNumber();
-    try {
-        const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
-            where: {
-                id: `UniswapV4_${computeChainId}_${poolID}`,
-                blockNumber: {
-                    lte: currentBlock,
-                },
-            },
-            orderBy: {
-                blockNumber: "desc",
-            },
-        });
-        stateSave = mostRecentStateSave.state;
-        blockNumber = mostRecentStateSave?.blockNumber;
-        states = stateSave.states;
-    }
-    catch {
-        log.warn(`merklDynamic data - failed to read a recent state of pool ${poolID} on ${NETWORK_LABELS[computeChainId]}`);
-        return { amount0: 0n, amount1: 0n, blockNumber: blockNumber ?? 0, nodesTVL };
-    }
-    const { fileName } = states;
-    // Root campaign info
-    const hasRulesOnPrice = !!campaign?.campaignParameters.lowerPriceBond || !!campaign?.campaignParameters.upperPriceBond;
-    let priceAtTick = 0n; // price in base 4
-    if (hasRulesOnPrice) {
-        const res = await ChainInteractionService(computeChainId).fetchArchiveState([
-            {
-                allowFailure: true,
-                callData: UniswapV4StateViewInterface.encodeFunctionData("getSlot0", [campaign.campaignParameters.poolId]),
-                target: UniswapV4Addresses[computeChainId].StateView,
-            },
-        ], blockNumber ?? currentBlock);
-        const poolData = UniswapV4StateViewInterface.decodeFunctionResult("getSlot0", res[0].returnData);
-        const tick = poolData.tick;
-        const sqrtRatioAtTick = BigInt(getSqrtRatioAtTick(tick).toString());
-        priceAtTick = getRawPriceFromSqrtRatioX96(1, sqrtRatioAtTick, campaign.campaignParameters.decimalsCurrency0, campaign.campaignParameters.decimalsCurrency1);
-    }
-    // SubCampaigns info
-    const nodes = await engineDbClient.nodes.findMany({
-        where: { chainId: computeChainId, nodeType: "GammaUniV4" },
-        select: { nodeType: true, recipient: true },
-    });
-    let amount0 = 0n;
-    let amount1 = 0n;
-    try {
-        // Bucket service
-        const bucket = new BucketService("merkl-production-states", "merkl-production");
-        const storedStates = JSON.parse(await bucket.pull(fileName));
-        for (const [_, { value, params }] of Object.entries(storedStates)) {
-            // _ Handle rules
-            if (!!hasRulesOnPrice && priceAtTick > 0n) {
-                if (!!campaign.campaignParameters.lowerPriceBond) {
-                    const lowerPriceBond = BigInt(campaign.campaignParameters.lowerPriceBond);
-                    const sqrtRatioAtLowerTick = BigInt(getSqrtRatioAtTick(params.additional.tickLower).toString());
-                    const priceAtLowerTick = getRawPriceFromSqrtRatioX96(1, sqrtRatioAtLowerTick, campaign.campaignParameters.decimalsCurrency0, campaign.campaignParameters.decimalsCurrency1);
-                    if (priceAtLowerTick < lowerPriceBond)
-                        continue;
-                }
-                if (!!campaign.campaignParameters.upperPriceBond) {
-                    const upperPriceBond = BigInt(campaign.campaignParameters.upperPriceBond);
-                    const sqrtRatioAtUpperTick = BigInt(getSqrtRatioAtTick(params.additional.tickUpper).toString());
-                    const priceAtUpperTick = getRawPriceFromSqrtRatioX96(1, sqrtRatioAtUpperTick, campaign.campaignParameters.decimalsCurrency0, campaign.campaignParameters.decimalsCurrency1);
-                    if (priceAtUpperTick > upperPriceBond)
-                        continue;
-                }
-            }
-            // _ Handle subcampaigns TVL
-            // ----------------- TEMPORARY: handle Gamma TVL
-            if (nodes.map(node => node.recipient).includes(params.recipient)) {
-                const node = nodes.find(node => node.recipient === params.recipient);
-                if (!node) {
-                    log.warn(`merklDynamic data - failed to find node ${params.recipient} for pool ${poolID}`);
-                    continue;
-                }
-                if (!nodesTVL[node.nodeType]) {
-                    nodesTVL[node.nodeType] = { amount0: 0n, amount1: 0n };
-                }
-                nodesTVL[node.nodeType].amount0 += BigInt(value.amount0);
-                nodesTVL[node.nodeType].amount1 += BigInt(value.amount1);
-                // -----------------
-            }
-            // _ Add amounts for TVL
-            amount0 += BigInt(value.amount0);
-            amount1 += BigInt(value.amount1);
-        }
-    }
-    catch {
-        log.warn(`merklDynamic data - failed to decode state of pool ${poolID} on ${NETWORK_LABELS[computeChainId]}`);
-    }
-    return { amount0, amount1, blockNumber: blockNumber, nodesTVL };
-}
-export class UniswapV4TVLBuilder {
-    async build(computeChainId, campaigns) {
-        const tvls = [];
-        for (const campaign of campaigns) {
-            const { amount0: poolBalanceToken0, amount1: poolBalanceToken1, nodesTVL, } = await computeUniV4PoolTVLFromMostRecentStateSave(computeChainId, campaign.campaignParameters.poolId, campaign);
-            const token0Id = TokenService.hashId({
-                chainId: computeChainId,
-                address: campaign.campaignParameters.currency0,
-            });
-            const token1Id = TokenService.hashId({
-                chainId: computeChainId,
-                address: campaign.campaignParameters.currency1,
-            });
-            if (Object.keys(nodesTVL).length > 0) {
-                for (const node of Object.values(nodesTVL)) {
-                    node.tvl =
-                        (await TokenService.getValueByTokenId(token0Id, node.amount0)) +
-                            (await TokenService.getValueByTokenId(token1Id, node.amount1));
-                }
-            }
-            tvls.push({
-                campaign,
-                tvl: (await TokenService.getValueByTokenId(token0Id, poolBalanceToken0)) +
-                    (await TokenService.getValueByTokenId(token1Id, poolBalanceToken1)),
-                tvlBreakdown: [
-                    {
-                        identifier: token0Id,
-                        type: TvlType.TOKEN,
-                        value: BN2Number(poolBalanceToken0, campaign.campaignParameters.decimalsCurrency0),
-                    },
-                    {
-                        identifier: token1Id,
-                        type: TvlType.TOKEN,
-                        value: BN2Number(poolBalanceToken1, campaign.campaignParameters.decimalsCurrency1),
-                    },
-                    // TEMPORARY: handle Gamma TVL
-                    ...(nodesTVL
-                        ? Object.entries(nodesTVL).map(([nodeType, { tvl }]) => ({
-                            identifier: nodeType,
-                            type: TvlType.PROTOCOL,
-                            value: tvl ?? 0,
-                        }))
-                        : []),
-                ],
-            });
-        }
-        return tvls;
-    }
-}

package/dist/src/engine/implementations/Vest/metadata.js

@@ -1,13 +0,0 @@
-import { VEST_TOKEN } from "@/engine/deprecated/dynamicData/implementations/Vest";
-import { OpportunityAction } from "@db/api";
-export class VestMetadata {
-    async build(campaign) {
-        const { computeChainId } = campaign;
-        return {
-            action: OpportunityAction.LEND,
-            name: ["Vest", "supply", "treasury"].join(" "),
-            tokens: [{ chainId: computeChainId, address: VEST_TOKEN }],
-            mainProtocol: "vest",
-        };
-    }
-}

package/dist/src/engine/metadata/factory.js

@@ -1,76 +0,0 @@
-import { Campaign } from "@sdk";
-import { AjnaMetadata } from "../implementations/Ajna/metadata";
-import { AmbientMetadata } from "../implementations/Ambient/metadata";
-import { BadgerMetadata } from "../implementations/Badger/metadata";
-import { ClammMetadata } from "../implementations/Clamm/metadata";
-import { CompoundMetadata } from "../implementations/Compound/metadata";
-import { CompoundV3Metadata } from "../implementations/CompoundV3/metadata";
-import { DefaultMetadata } from "../implementations/Default/metadata";
-import { DolomiteMetadata } from "../implementations/Dolomite/metadata";
-import { EigenLayerMetadata } from "../implementations/EigenLayer/metadata";
-import { EncompassingMetadata } from "../implementations/Encompassing/metadata";
-import { Erc20Metadata } from "../implementations/Erc20/metadata";
-import { Erc721Metadata } from "../implementations/Erc721/metadata";
-import { ErcMultiTokenMetadata } from "../implementations/ErcMultiToken/metadata";
-import { EventBasedMetadata } from "../implementations/EventBased/metadata";
-import { HyperdriveMetadata } from "../implementations/Hyperdrive/metadata";
-import { InvalidMetadata } from "../implementations/Invalid/metadata";
-import { IonMetadata } from "../implementations/Ion/metadata";
-import { JsonAirdropMetadata } from "../implementations/JsonAirdrop/metadata";
-import { LockerMetadata } from "../implementations/Locker/metadata";
-import { MorphoMetadata } from "../implementations/Morpho/metadata";
-import { MultiLogMetaData } from "../implementations/MultiLog/metadata";
-import { RadiantMetadata } from "../implementations/Radiant/metadata";
-import { SiloMetadata } from "../implementations/Silo/metadata";
-import { UniswapV4Metadata } from "../implementations/UniswapV4/metadata";
-import { VestMetadata } from "../implementations/Vest/metadata";
-/**
- * @dev Casts are made to enforce type safety
- * @dev A type error must be thrown if a new campaign type is added and the corresponding builder is not implemented
- */
-const map = {
-    [Campaign.INVALID]: new InvalidMetadata(),
-    [Campaign.ERC20]: new Erc20Metadata(),
-    [Campaign.CLAMM]: new ClammMetadata(),
-    [Campaign.ERC20_SNAPSHOT]: new Erc20Metadata(),
-    [Campaign.JSON_AIRDROP]: new JsonAirdropMetadata(),
-    [Campaign.SILO]: new SiloMetadata(),
-    [Campaign.RADIANT]: new RadiantMetadata(),
-    [Campaign.DOLOMITE]: new DolomiteMetadata(),
-    [Campaign.BADGER]: new BadgerMetadata(),
-    [Campaign.AJNA]: new AjnaMetadata(),
-    [Campaign.EULER]: new Erc20Metadata(),
-    [Campaign.COMPOUND]: new CompoundMetadata(),
-    [Campaign.COMPOUND_V3]: new CompoundV3Metadata(),
-    [Campaign.COMPOUND_V3_FIXAPR]: new CompoundV3Metadata(),
-    [Campaign.ION]: new IonMetadata(),
-    [Campaign.MORPHO]: new MorphoMetadata(),
-    [Campaign.HYPERDRIVELOGFIXPROCESSOR]: new HyperdriveMetadata(),
-    [Campaign.HYPERDRIVELOGPROCESSOR]: new HyperdriveMetadata(),
-    [Campaign.ERC20_FIX_APR]: new Erc20Metadata(),
-    [Campaign.UNISWAP_V4]: new UniswapV4Metadata(),
-    [Campaign.EIGENLAYER]: new EigenLayerMetadata(),
-    [Campaign.VEST]: new VestMetadata(),
-    [Campaign.ERC20LOGPROCESSOR]: new Erc20Metadata(),
-    [Campaign.ERC20REBASELOGPROCESSOR]: new Erc20Metadata(),
-    [Campaign.M0]: new DefaultMetadata(), // TODO
-    [Campaign.MORPHOSUPPLY]: new DefaultMetadata(), // TODO
-    [Campaign.SYNCSWAP_VAULT]: new DefaultMetadata(), // TODO
-    [Campaign.AMBIENTPROCESSOR]: new AmbientMetadata(),
-    [Campaign.ENCOMPASSING]: new EncompassingMetadata(),
-    [Campaign.EVENT_BASED]: new EventBasedMetadata(),
-    [Campaign.ERC20REBASEFIXAPR]: new Erc20Metadata(),
-    [Campaign.MAVERICK_BP]: new DefaultMetadata(), // TODO
-    [Campaign.ERC6909]: new ErcMultiTokenMetadata(),
-    [Campaign.ERC6909FIXAPR]: new ErcMultiTokenMetadata(),
-    [Campaign.ERC1155]: new ErcMultiTokenMetadata(),
-    [Campaign.ERC1155FIXAPR]: new ErcMultiTokenMetadata(),
-    [Campaign.ERC721]: new Erc721Metadata(),
-    [Campaign.ERC721FIXAPR]: new Erc721Metadata(),
-    [Campaign.MULTILOG]: new MultiLogMetaData(),
-    [Campaign.MULTILOG_DUTCH]: new MultiLogMetaData(),
-    [Campaign.LOCKER]: new LockerMetadata(),
-    [Campaign.CONVEX]: new DefaultMetadata(), // TODO
-    [Campaign.STAKEDAO_CURVEVAULT]: new DefaultMetadata(), // TODO
-};
-export const metadataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/tvl/factory.js

@@ -1,87 +0,0 @@
-import { UniswapV4TVLBuilder } from "@/engine/implementations/UniswapV4/tvl";
-import { Campaign } from "@sdk";
-import { BadgerDynamicData } from "../deprecated/dynamicData/implementations/Badger";
-import { ClammDynamicData } from "../deprecated/dynamicData/implementations/Clamm";
-import { CompoundDynamicData } from "../deprecated/dynamicData/implementations/Compound";
-import { CompoundV3DynamicData } from "../deprecated/dynamicData/implementations/CompoundV3";
-import { DolomiteDynamicData } from "../deprecated/dynamicData/implementations/Dolomite";
-import { ERC721DynamicData } from "../deprecated/dynamicData/implementations/ERC721";
-import { ERCMultiTokenDynamicData } from "../deprecated/dynamicData/implementations/ERCMultiToken";
-import { EncompassingDynamicData } from "../deprecated/dynamicData/implementations/Encompassing";
-import { Erc20SnapshotDynamicData } from "../deprecated/dynamicData/implementations/Erc20Snapshot";
-import { EventBasedDynamicData } from "../deprecated/dynamicData/implementations/EventBased";
-import { HyperdriveDynamicData } from "../deprecated/dynamicData/implementations/Hyperdrive";
-import { MorphoDynamicData } from "../deprecated/dynamicData/implementations/Morpho";
-import { RadiantDynamicData } from "../deprecated/dynamicData/implementations/Radiant";
-import { SiloDynamicData } from "../deprecated/dynamicData/implementations/Silo";
-import { VestDynamicData } from "../deprecated/dynamicData/implementations/Vest";
-import { AjnaTVLBuilder } from "../implementations/Ajna/tvl";
-import { EigenLayerTVLBuilder } from "../implementations/EigenLayer/tvl";
-import { Erc20TVLBuilder } from "../implementations/Erc20/tvl";
-import { LockerTVLBuilder } from "../implementations/Locker/tvl";
-import { MultiLogTVLBuilder } from "../implementations/MultiLog/tvl";
-class defaultTVLBuilder {
-    async build() {
-        return [];
-    }
-}
-function Deprecated(x) {
-    return {
-        deprecated: true,
-        build: x.build,
-    };
-}
-/**
- * @dev TYPE SAFETY DISABLED FOR NOW AS WE DON'T HAVE ALL THE CAMPAIGNS IMPLEMENTED
- *
- * @dev Casts are made to enforce type safety
- * @dev A type error must be thrown if a new campaign type is added and the corresponding builder is not implemented
- */
-const map = {
-    [Campaign.INVALID]: new defaultTVLBuilder(),
-    [Campaign.JSON_AIRDROP]: new defaultTVLBuilder(),
-    [Campaign.AJNA]: new AjnaTVLBuilder(),
-    [Campaign.AMBIENTPROCESSOR]: new defaultTVLBuilder(),
-    [Campaign.BADGER]: Deprecated(new BadgerDynamicData()),
-    [Campaign.CLAMM]: Deprecated(new ClammDynamicData()),
-    [Campaign.COMPOUND]: Deprecated(new CompoundDynamicData()),
-    [Campaign.COMPOUND_V3]: Deprecated(new CompoundV3DynamicData()),
-    [Campaign.COMPOUND_V3_FIXAPR]: Deprecated(new CompoundV3DynamicData()),
-    [Campaign.DOLOMITE]: Deprecated(new DolomiteDynamicData()),
-    [Campaign.EIGENLAYER]: new EigenLayerTVLBuilder(),
-    [Campaign.ENCOMPASSING]: Deprecated(new EncompassingDynamicData()),
-    [Campaign.ERC20_SNAPSHOT]: Deprecated(new Erc20SnapshotDynamicData()),
-    [Campaign.EVENT_BASED]: Deprecated(new EventBasedDynamicData()),
-    [Campaign.HYPERDRIVELOGFIXPROCESSOR]: Deprecated(new HyperdriveDynamicData()),
-    [Campaign.HYPERDRIVELOGPROCESSOR]: Deprecated(new HyperdriveDynamicData()),
-    [Campaign.UNISWAP_V4]: new UniswapV4TVLBuilder(),
-    [Campaign.ERC20]: new Erc20TVLBuilder(),
-    [Campaign.ERC20LOGPROCESSOR]: new Erc20TVLBuilder(),
-    [Campaign.ERC20REBASEFIXAPR]: new Erc20TVLBuilder(),
-    [Campaign.ERC20REBASELOGPROCESSOR]: new Erc20TVLBuilder(),
-    [Campaign.ERC20_FIX_APR]: new Erc20TVLBuilder(),
-    [Campaign.EULER]: new Erc20TVLBuilder(),
-    [Campaign.MORPHO]: Deprecated(new MorphoDynamicData()),
-    [Campaign.RADIANT]: Deprecated(new RadiantDynamicData()),
-    [Campaign.SILO]: Deprecated(new SiloDynamicData()),
-    [Campaign.MULTILOG]: new MultiLogTVLBuilder(),
-    [Campaign.MULTILOG_DUTCH]: new MultiLogTVLBuilder(),
-    [Campaign.LOCKER]: new LockerTVLBuilder(),
-    [Campaign.VEST]: Deprecated(new VestDynamicData()),
-    [Campaign.ION]: new defaultTVLBuilder(), // TODO
-    [Campaign.M0]: new defaultTVLBuilder(), // TODO
-    [Campaign.MORPHOSUPPLY]: new defaultTVLBuilder(), // TODO
-    [Campaign.SYNCSWAP_VAULT]: new defaultTVLBuilder(), // TODO
-    [Campaign.MAVERICK_BP]: new defaultTVLBuilder(), // TODO
-    [Campaign.ERC6909]: Deprecated(new ERCMultiTokenDynamicData()),
-    [Campaign.ERC6909FIXAPR]: Deprecated(new ERCMultiTokenDynamicData()),
-    [Campaign.ERC1155]: Deprecated(new ERCMultiTokenDynamicData()),
-    [Campaign.ERC1155FIXAPR]: Deprecated(new ERCMultiTokenDynamicData()),
-    [Campaign.ERC721]: Deprecated(new ERC721DynamicData()),
-    [Campaign.ERC721FIXAPR]: Deprecated(new ERC721DynamicData()),
-    [Campaign.CONVEX]: new defaultTVLBuilder(), // TODO
-    [Campaign.STAKEDAO_CURVEVAULT]: new defaultTVLBuilder(), // TODO
-};
-export const campaignTVLBuilderFactory = (campaignType) => {
-    return map[campaignType];
-};