@merkl/api 0.9.15

package/dist/src/engine/opportunityMetadata/implementations/Clamm.js

@@ -0,0 +1,50 @@
+import { camelToKebabCase } from "@/utils/caseChanges";
+import { OpportunityAction } from "@db/api";
+import { AMM, ChainId, almName, ammName, } from "@sdk";
+import { getAddress } from "viem";
+export class ClammMetadata {
+    async build(computeChainId, params) {
+        let platform = ammName(params.amm);
+        if (platform === "BaseSwap") {
+            switch (computeChainId) {
+                case ChainId.MODE:
+                    platform = "SwapMode";
+                    break;
+                case ChainId.ARBITRUM:
+                    platform = "Arbitex";
+                    break;
+                case ChainId.OPTIMISM:
+                    platform = "SuperSwap";
+            }
+        }
+        if (platform === "Izumi") {
+            if (computeChainId === ChainId.ROOTSTOCK)
+                platform = "WoodSwap";
+            else
+                platform = "iZUMi";
+        }
+        let 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?.type;
+                const forwarderName = !!forwarderType ? almName(forwarderType) : null;
+                if (!!forwarderName) {
+                    whitelistNameString += ` ${forwarderName} `;
+                }
+            }
+        }
+        return {
+            name: `Provide liquidity to ${whitelistNameString} ${platform} ${params.symbolToken0}-${params.symbolToken1}${params.poolFee ? ` ${params.poolFee}%` : ""}`,
+            action: OpportunityAction.POOL,
+            tokens: [
+                { chainId: computeChainId, address: params.token0 },
+                { chainId: computeChainId, address: params.token1 },
+            ],
+            mainProtocol: AMM[params.amm] ? camelToKebabCase(AMM[params.amm]) : undefined,
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Compound.d.ts

@@ -0,0 +1,16 @@
+import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { ProtocolId } from "../../../modules/v4/protocol/protocol.model";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.COMPOUND;
+export declare class CompoundMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: ProtocolId;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Compound.js

@@ -0,0 +1,20 @@
+import { OpportunityAction } from "@db/api";
+import { CompFork, CompoundSubCampaignType, } from "@sdk";
+export class CompoundMetadata {
+    async build(computeChainId, params, subType) {
+        return {
+            action: subType === CompoundSubCampaignType.supply ? OpportunityAction.LEND : OpportunityAction.BORROW,
+            name: [
+                subType === CompoundSubCampaignType.supply
+                    ? `Supply ${params.symbolUnderlyingToken} on`
+                    : `Borrow ${params.symbolUnderlyingToken} on`,
+                CompFork[params.compFork],
+            ].join(" "),
+            tokens: [
+                { chainId: computeChainId, address: params.underlyingToken },
+                { chainId: computeChainId, address: params.targetToken },
+            ],
+            mainProtocol: CompFork[params.compFork].toLowerCase(),
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Default.d.ts

@@ -0,0 +1,13 @@
+import type { Campaign as CampaignEnum } from "@sdk";
+import type { CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum;
+export declare class DefaultMetadata implements MetadataBuilder<campaignType> {
+    build(_computeChainId: ChainId, _params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "HOLD";
+        name: string;
+        tokens: never[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Default.js

@@ -0,0 +1,11 @@
+import { OpportunityAction } from "@db/api";
+export class DefaultMetadata {
+    async build(_computeChainId, _params) {
+        return {
+            action: OpportunityAction.HOLD,
+            name: "Reward Opportunity",
+            tokens: [],
+            mainProtocol: "",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Dolomite.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.DOLOMITE;
+export declare class DolomiteMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        name: string;
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Dolomite.js

@@ -0,0 +1,17 @@
+import { OpportunityAction } from "@db/api";
+export class DolomiteMetadata {
+    async build(computeChainId, params, subType) {
+        const subtypes = [
+            { name: "Supply (delta)", action: OpportunityAction.LEND },
+            { name: "Supply", action: OpportunityAction.LEND },
+            { name: "Borrow", action: OpportunityAction.BORROW },
+        ];
+        const subtype = subtypes[subType];
+        return {
+            action: subtype.action,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            name: `${subtype.name} ${params.symbolTargetToken}`,
+            mainProtocol: "dolomite",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/EigenLayer.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.EIGENLAYER;
+export declare class EigenLayerMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "LEND";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/EigenLayer.js

@@ -0,0 +1,11 @@
+import { OpportunityAction } from "@db/api";
+export class EigenLayerMetadata {
+    async build(computeChainId, params) {
+        return {
+            action: OpportunityAction.LEND,
+            name: ["EigenLayer", "strategy for", params.symbolUnderlyingToken].join(" "),
+            tokens: [{ chainId: computeChainId, address: params.underlyingToken }],
+            mainProtocol: "eigenlayer",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Encompassing.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ENCOMPASSING;
+export declare class EncompassingMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"], rewardTokenAddress: string): Promise<{
+        action: "DROP";
+        name: any;
+        tokens: {
+            chainId: ChainId;
+            address: string;
+        }[];
+        mainProtocol: any;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Encompassing.js

@@ -0,0 +1,37 @@
+import { log } from "@/utils/logger";
+import { OpportunityAction } from "@db/api";
+export class EncompassingMetadata {
+    async build(computeChainId, params, _subType, rewardTokenAddress) {
+        try {
+            const dataResponse = await fetch(params.dataUrl);
+            if (!dataResponse.ok)
+                throw new Error(`Response status: ${dataResponse.status}`);
+            const data = await dataResponse.json();
+            return {
+                action: OpportunityAction.DROP,
+                name: data.opportunityName ?? `Distribution of ${params.symbolRewardToken}`,
+                tokens: [
+                    {
+                        chainId: computeChainId,
+                        address: rewardTokenAddress,
+                    },
+                ],
+                mainProtocol: data.mainProtocol ?? undefined,
+            };
+        }
+        catch (err) {
+            log.error("failed to fetch data from dataUrl", err);
+            return {
+                action: OpportunityAction.DROP,
+                name: `Distribution of ${params.symbolRewardToken}`,
+                tokens: [
+                    {
+                        chainId: computeChainId,
+                        address: rewardTokenAddress,
+                    },
+                ],
+                mainProtocol: undefined,
+            };
+        }
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Erc20.d.ts

@@ -0,0 +1,15 @@
+import { Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ERC20;
+export declare class Erc20Metadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"], rewardTokenAddress: string, distributionChainId: ChainId, campaignId: string): Promise<{
+        action: import("@db/api").$Enums.OpportunityAction;
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: any;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Erc20.js

@@ -0,0 +1,71 @@
+import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
+import { log } from "@/utils/logger";
+import { Campaign as CampaignEnum } from "@sdk";
+import { ProtocolService } from "../../../modules/v4/protocol/protocol.service";
+export class Erc20Metadata {
+    async build(computeChainId, params, _subType, rewardTokenAddress, distributionChainId, campaignId) {
+        let action = "HOLD";
+        let name = `Hold ${params.symbolTargetToken}`;
+        let mainProtocolId = undefined;
+        const tokens = [{ chainId: computeChainId, address: params.targetToken }];
+        try {
+            const [dynamicData] = await dynamicDataBuilderFactory(CampaignEnum.ERC20).build(computeChainId, [
+                {
+                    campaignId,
+                    rewardToken: rewardTokenAddress,
+                    amount: "1",
+                    chainId: distributionChainId,
+                    computeChainId,
+                    campaignParameters: params,
+                },
+            ]);
+            action = dynamicData?.typeInfo?.action ?? action;
+            name = dynamicData?.typeInfo?.cardName;
+            mainProtocolId = dynamicData?.typeInfo?.protocol?.toLowerCase().replace(" ", "");
+            const protocol = (await ProtocolService.findMany({ id: mainProtocolId }))?.[0];
+            if (!!protocol) {
+                mainProtocolId = protocol?.id;
+            }
+            // Case of lending protocols and receipt tokens
+            if (!!dynamicData && !!dynamicData.typeInfo?.underlying) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.underlying });
+            }
+            // Case of perps protocols
+            if (!!dynamicData && !!dynamicData.typeInfo?.shortToken && !!dynamicData.typeInfo?.longToken) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.shortToken });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.longToken });
+            }
+            // Case of weird AMMs
+            if (!!dynamicData && !!dynamicData.typeInfo?.tokenA && !!dynamicData.typeInfo?.tokenB) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.tokenA });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.tokenB });
+            }
+            // Case of AMMs
+            if (!!dynamicData && !!dynamicData.typeInfo?.token0 && !!dynamicData.typeInfo?.token1) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token0 });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token1 });
+            }
+            // Case of tripools
+            if (!!dynamicData &&
+                !!dynamicData.typeInfo?.token0Address &&
+                !!dynamicData.typeInfo?.token1Address &&
+                !!dynamicData.typeInfo?.token2Address) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token0Address });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token1Address });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token2Address });
+            }
+        }
+        catch {
+            log.warn(`failed to fetch dynamic data for ERC20 campaign ${campaignId}`);
+        }
+        if (mainProtocolId === "unknown") {
+            mainProtocolId = undefined;
+        }
+        return {
+            action,
+            name,
+            tokens,
+            mainProtocol: mainProtocolId,
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Erc20Snapshot.d.ts

@@ -0,0 +1,14 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ERC20_SNAPSHOT;
+export declare class Erc20SnapshotMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        name: string;
+        action: "DROP";
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Erc20Snapshot.js

@@ -0,0 +1,10 @@
+import { OpportunityAction } from "@db/api";
+export class Erc20SnapshotMetadata {
+    async build(computeChainId, params) {
+        return {
+            name: ["Get", params.symbolTargetToken, "airdrop"].join(" "),
+            action: OpportunityAction.DROP,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Euler.d.ts

@@ -0,0 +1,15 @@
+import { Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.EULER;
+export declare class EulerMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"], rewardTokenAddress: string, distributionChainId: ChainId, campaignId: string): Promise<{
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        action: "LEND" | "BORROW";
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Euler.js

@@ -0,0 +1,34 @@
+import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
+import { log } from "@/utils/logger";
+import { OpportunityAction } from "@db/api";
+import { Campaign as CampaignEnum } from "@sdk";
+export class EulerMetadata {
+    async build(computeChainId, params, subType, rewardTokenAddress, distributionChainId, campaignId) {
+        let name = `Hold ${params.symbolTargetToken}`;
+        try {
+            const [dynamicData] = await dynamicDataBuilderFactory(CampaignEnum.EULER).build(computeChainId, [
+                {
+                    campaignId,
+                    rewardToken: rewardTokenAddress,
+                    amount: "1",
+                    chainId: distributionChainId,
+                    computeChainId,
+                    campaignParameters: params,
+                },
+            ]);
+            name = dynamicData?.typeInfo?.cardName;
+        }
+        catch {
+            log.warn(`failed to fetch dynamic data for ERC20 campaign ${campaignId}`);
+        }
+        return {
+            name,
+            tokens: [
+                { chainId: computeChainId, address: params.targetToken },
+                { chainId: computeChainId, address: params.addressAsset },
+            ],
+            action: [OpportunityAction.LEND, OpportunityAction.BORROW, OpportunityAction.BORROW][subType],
+            mainProtocol: "euler",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/EventBased.d.ts

@@ -0,0 +1,20 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.EVENT_BASED;
+export declare class EventBasedMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "SWAP";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    } | {
+        action: string;
+        name: string;
+        tokens: never[];
+        mainProtocol: undefined;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/EventBased.js

@@ -0,0 +1,45 @@
+export class EventBasedMetadata {
+    async build(computeChainId, params, _subType) {
+        try {
+            const action = "SWAP";
+            const mainProtocolId = "Hanji";
+            let name = `${params.eventID.split("(")[0]} on ${mainProtocolId}`;
+            let tokens = [{ chainId: computeChainId, address: params.contract }];
+            if (params.contract.toLowerCase() === "0xd0bc067cf877f7b76ceb331891331d9e6acda1a7") {
+                name = `Trade USDC/XTZ on ${mainProtocolId}`;
+                tokens = [
+                    { chainId: computeChainId, address: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9" },
+                    { chainId: computeChainId, address: "0xc9B53AB2679f573e480d01e0f49e2B5CFB7a3EAb" },
+                ];
+            }
+            if (params.contract.toLowerCase() === "0x65ea4dd7f789c71c0f57ed84b3bdc3062898d3cb") {
+                name = `Trade USDC/ETH on ${mainProtocolId}`;
+                tokens = [
+                    { chainId: computeChainId, address: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9" },
+                    { chainId: computeChainId, address: "0xfc24f770F94edBca6D6f885E12d4317320BcB401" },
+                ];
+            }
+            if (params.contract.toLowerCase() === "0xbb6b01d94e3f6ebae8647cb56d544f57928ab758") {
+                name = `Trade USDC/BTC on ${mainProtocolId}`;
+                tokens = [
+                    { chainId: computeChainId, address: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9" },
+                    { chainId: computeChainId, address: "0xbFc94CD2B1E55999Cfc7347a9313e88702B83d0F" },
+                ];
+            }
+            return {
+                action,
+                name,
+                tokens,
+                mainProtocol: mainProtocolId.toLowerCase(),
+            };
+        }
+        catch {
+            return {
+                action: "INVALID",
+                name: "Event Based Campaign",
+                tokens: [],
+                mainProtocol: undefined,
+            };
+        }
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Hyperdrive.d.ts

@@ -0,0 +1,15 @@
+import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.HYPERDRIVELOGPROCESSOR | CampaignEnum.HYPERDRIVELOGFIXPROCESSOR;
+export declare class HyperdriveMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "POOL" | "LONG" | "SHORT";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Hyperdrive.js

@@ -0,0 +1,21 @@
+import { OpportunityAction } from "@db/api";
+import { HyperDriveSubCampaignType } from "@sdk";
+export class HyperdriveMetadata {
+    async build(computeChainId, params, subType) {
+        const subtypes = [
+            { name: "Add Liquidity on", action: OpportunityAction.POOL },
+            { name: "Open Long on", action: OpportunityAction.LONG },
+            { name: "Open Short on", action: OpportunityAction.SHORT },
+        ];
+        if (subType === HyperDriveSubCampaignType.LP) {
+            subType = 0;
+        }
+        const subtypeData = subtypes[subType];
+        return {
+            action: subtypeData.action,
+            name: [subtypeData.name, params.symbolTargetToken].join(" "),
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: "hyperdrive",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Invalid.d.ts

@@ -0,0 +1,11 @@
+import type { Campaign as CampaignEnum } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.INVALID;
+export declare class InvalidMetadata implements MetadataBuilder<campaignType> {
+    build(): Promise<{
+        name: string;
+        action: "INVALID";
+        tokens: never[];
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Invalid.js

@@ -0,0 +1,10 @@
+import { OpportunityAction } from "@db/api";
+export class InvalidMetadata {
+    async build() {
+        return {
+            name: "Invalid Campaigns",
+            action: OpportunityAction.INVALID,
+            tokens: [],
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Ion.d.ts

@@ -0,0 +1,16 @@
+import type { Campaign as CampaignEnum } from "@sdk";
+import type { CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ION;
+export declare class IonMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "LEND";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Ion.js

@@ -0,0 +1,15 @@
+import { OpportunityAction } from "@db/api";
+export class IonMetadata {
+    async build(computeChainId, params) {
+        // TODO this is not finalized at all
+        return {
+            action: OpportunityAction.LEND,
+            name: ["Ion", "strategy for", params.symbolBorrowToken].join(" "),
+            tokens: [
+                { chainId: computeChainId, address: params.borrowToken },
+                { chainId: computeChainId, address: params.collateralToken },
+            ],
+            mainProtocol: "ion",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/JsonAirdrop.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.JSON_AIRDROP;
+export declare class JsonAirdropMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"], _rewardTokenAddress: string, _distributionChainId: ChainId, _campaignId: string, creator: string): Promise<{
+        action: "DROP";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: string;
+        }[];
+        mainProtocol: string | undefined;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/JsonAirdrop.js

@@ -0,0 +1,38 @@
+import { log } from "@/utils/logger";
+import { OpportunityAction } from "@db/api";
+export class JsonAirdropMetadata {
+    async build(computeChainId, params, _subType, _rewardTokenAddress, _distributionChainId, _campaignId, creator) {
+        const ACI = "0xdeadD8aB03075b7FBA81864202a2f59EE25B312b".toLowerCase();
+        const aaveDAO = "0x5300A1a15135EA4dc7aD5a167152C01EFc9b192A".toLowerCase();
+        const aciPrefix = creator.toLowerCase() === ACI && "Get Merit rewards -";
+        const aavePrefix = creator.toLowerCase() === aaveDAO && "Get aAMPL distribution -";
+        const prefix = aavePrefix ? aavePrefix : aciPrefix ? aciPrefix : "Get airdrop in";
+        let tokenAddress;
+        try {
+            const res = await fetch(params.jsonUrl);
+            if (!res.ok)
+                throw new Error(`Response status: ${res.status}`);
+            tokenAddress = (await res.json()).rewardToken;
+            return {
+                action: OpportunityAction.DROP,
+                name: `${prefix} ${params.symbolRewardToken}`,
+                tokens: [
+                    {
+                        chainId: computeChainId,
+                        address: tokenAddress, // TODO: Make sure targetToken is set
+                    },
+                ],
+                mainProtocol: aavePrefix || aciPrefix ? "aave" : undefined,
+            };
+        }
+        catch (err) {
+            log.error("failed to fetch token address on IPFS", err);
+            return {
+                action: OpportunityAction.DROP,
+                name: `${prefix} ${params.symbolRewardToken}`,
+                tokens: [],
+                mainProtocol: aavePrefix || aciPrefix ? "aave" : undefined,
+            };
+        }
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Morpho.d.ts

@@ -0,0 +1,15 @@
+import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.MORPHO;
+export declare class MorphoMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        name: string;
+        mainProtocol: string;
+    }>;
+}
+export {};