@merkl/api 0.10.129 → 0.10.131

package/dist/src/modules/v4/opportunity/opportunity.service.js

@@ -0,0 +1,180 @@
+import { NotFoundError } from "../../../errors";
+import { CampaignService } from "../campaign";
+import { log } from "../../../utils/logger";
+import { OpportunityAction, Prisma } from "../../../../database/api/.generated";
+import { record } from "@elysiajs/opentelemetry";
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
+import { OpportunityRepository } from "./opportunity.repository";
+import { getAjnaMetadata } from "./subservices/getAjnaMetadata.service";
+import { getBadgerMetadata } from "./subservices/getBadgerMetadata.service";
+import { getClammMetadata } from "./subservices/getClammMetadata.service";
+import { getCompoundMetadata } from "./subservices/getCompoundMetadata.service";
+import { getDolomiteMetadata } from "./subservices/getDolomiteMetadata.service";
+import { getErc20Metadata } from "./subservices/getErc20Metadata.service";
+import { getErc20SnapshotMetadata } from "./subservices/getErc20SnapshotMetadata.service";
+import { getEulerMetadata } from "./subservices/getEulerMetadata.service";
+import { getJsonAirdropMetadata } from "./subservices/getJsonAirDropMetadata.service";
+import { getMorphoMetadata } from "./subservices/getMorphoMetadata.service";
+import { getRadiantMetadata } from "./subservices/getRadiantMetadata.service";
+import { getSiloMetadata } from "./subservices/getSiloMetadata.service";
+export class OpportunityService {
+    static hashId(opportunity) {
+        return Bun.hash(`${opportunity.chainId}${opportunity.type}${opportunity.identifier}`).toString();
+    }
+    /**
+     * create an opportunity without campaigns
+     * @param newOpp the new opportunity to create
+     * @returns {Promise<Opportunity|undefined>}
+     */
+    static async create(newOpp) {
+        const id = OpportunityService.hashId(newOpp);
+        return await OpportunityRepository.create({ ...newOpp, id });
+    }
+    /**
+     * build/fetch metadata of a campaign's opportunity
+     * @param campaign
+     * @returns {OpportunityMetadata}
+     */
+    static async getMetadata(campaign) {
+        const campaignType = CampaignService.getTypeFromV3(campaign.type);
+        const campaignParams = JSON.parse(campaign.params);
+        const chainId = campaign.computeChainId === 0 ? campaign.chainId : campaign.computeChainId;
+        switch (campaignType) {
+            case "CLAMM":
+                return getClammMetadata(chainId, campaignParams);
+            case "ERC20":
+                return getErc20Metadata(chainId, campaign.campaignId, campaign.rewardTokenAddress, campaign.amount, campaignParams);
+            case "ERC20_SNAPSHOT":
+                return getErc20SnapshotMetadata(chainId, campaignParams);
+            case "JSON_AIRDROP":
+                return getJsonAirdropMetadata(chainId, campaign.creator, campaignParams);
+            case "SILO":
+                return getSiloMetadata(chainId, campaign.subType, campaignParams);
+            case "RADIANT":
+                return getRadiantMetadata(chainId, campaign.subType, campaignParams);
+            case "MORPHO":
+                return getMorphoMetadata(chainId, campaign.subType, campaignParams);
+            case "DOLOMITE":
+                return getDolomiteMetadata(chainId, campaign.subType, campaignParams);
+            case "BADGER":
+                return getBadgerMetadata(chainId, campaignParams);
+            case "COMPOUND":
+                return getCompoundMetadata(chainId, campaign.subType, campaignParams);
+            case "AJNA":
+                return getAjnaMetadata(chainId, campaign.subType, campaignParams);
+            case "EULER":
+                return getEulerMetadata(chainId, campaign.campaignId, campaign.subType, campaign.rewardTokenAddress, campaign.amount, campaignParams);
+            case "INVALID":
+                return {
+                    name: "Invalid Campaigns",
+                    action: OpportunityAction.INVALID,
+                    tokens: [],
+                };
+            default:
+                throw "UNKNOWN CAMPAIGN TYPE";
+        }
+    }
+    static async updateMetadata(chain) {
+        try {
+            const opportunities = await OpportunityRepository.findManyWithCampaigns({
+                where: { chainId: chain },
+            });
+            // ─── Check And Update Opportunity Status ─────────────
+            for (const opp of opportunities) {
+                const { live: activeCampaigns, soon: futureCampaigns } = CampaignService.splitOnStatus(opp.Campaigns);
+                if (activeCampaigns.length === 0) {
+                    await OpportunityRepository.updateApr(opp.id, 0);
+                    await OpportunityRepository.updateStatus(opp.id, futureCampaigns.length === 0 ? "PAST" : "SOON").catch(err => log.error("Cannot update opportunity status to PAST", err, "opportunities"));
+                }
+                if (opp.status !== "LIVE" && activeCampaigns.length !== 0)
+                    await OpportunityRepository.updateStatus(opp.id, "LIVE").catch(err => log.error("Cannot update opportunity status to LIVE", err, "opportunities"));
+            }
+        }
+        catch (err) {
+            if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2025")
+                throw new NotFoundError();
+            throw err;
+        }
+    }
+    static async getUniqueWithCampaignsOrThrow(opportunityId) {
+        const id = typeof opportunityId === "string" ? opportunityId : OpportunityService.hashId(opportunityId);
+        const { Campaigns, ...opportunity } = await OpportunityRepository.findUniqueOrThrowWithCampaigns(id);
+        const formatted = OpportunityService.formatResponse(opportunity);
+        if (!formatted)
+            return null;
+        return Object.assign(formatted, { campaigns: Campaigns.map(CampaignService.format) });
+    }
+    static async getUniqueOrThrow(opportunityId) {
+        const id = typeof opportunityId === "string" ? opportunityId : OpportunityService.hashId(opportunityId);
+        const opportunity = await OpportunityRepository.findUniqueOrThrow(id);
+        return OpportunityService.formatResponse(opportunity);
+    }
+    /**
+     * Get the list of opportunities satisfying the query
+     * @param query
+     * @returns A list of opportunities
+     */
+    static async getMany(query) {
+        return record("data-layer.access", async () => {
+            return await CacheService.wrap(TTLPresets.MIN_5, async (query) => {
+                const opportunities = await OpportunityRepository.findMany(query);
+                return opportunities.map(OpportunityService.formatResponse);
+            }, query);
+        });
+    }
+    static async getAllIds() {
+        return await OpportunityRepository.getAllIdsForDynamicOpp();
+    }
+    /**
+     * Counts the number of opportunities that complies to query
+     * @description used for pagination purposes
+     * @param query
+     * @returns the number of opportunities
+     */
+    static async countMany(query) {
+        return await OpportunityRepository.countMany(query);
+    }
+    static formatResponse(opportunity) {
+        if (opportunity === null)
+            return null;
+        const { DailyRewardsRecords, AprRecords, TvlRecords, ...opp } = opportunity;
+        return {
+            ...OpportunityService.formatResponseBase(opp),
+            aprRecord: AprRecords?.map(({ cumulated, timestamp, AprBreakdown: breakdowns }) => ({
+                cumulated,
+                timestamp,
+                breakdowns,
+            }))?.[0] ?? undefined,
+            tvlRecord: TvlRecords?.map(({ id, total, timestamp, TvlBreakdown: breakdowns }) => ({
+                id,
+                total,
+                timestamp,
+                breakdowns,
+            }))?.[0] ?? undefined,
+            rewardsRecord: DailyRewardsRecords?.map(({ id, total, timestamp, DailyRewardsBreakdown: breakdowns }) => ({
+                id,
+                total,
+                timestamp,
+                breakdowns: breakdowns.map(({ Campaign, ...breakdown }) => {
+                    return {
+                        token: Campaign.RewardToken,
+                        amount: CampaignService.getDailyAmount(Campaign.startTimestamp, Campaign.endTimestamp, BigInt(Campaign.amount)),
+                        ...breakdown,
+                    };
+                }),
+            }))?.[0] ?? undefined,
+            //TODO: change this to accomodate all return types
+        };
+    }
+    static formatResponseBase(opportunity) {
+        const { mainProtocolId, id, Tokens, Chain, Protocols, MainProtocol, ...opp } = opportunity;
+        return {
+            ...opp,
+            id,
+            tokens: Tokens,
+            chain: Chain,
+            protocol: MainProtocol ?? undefined,
+        };
+    }
+}

package/dist/src/modules/v4/opportunity/subservices/getAjnaMetadata.service.js

@@ -0,0 +1,50 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+import { TokenService } from "../../token";
+export const getAjnaMetadata = async (chainId, campaignSubType, params) => {
+    try {
+        const [collateral, quote] = await TokenService.getManyOrCreate([
+            {
+                chainId,
+                address: params.collateralToken,
+            },
+            {
+                chainId,
+                address: params.quoteToken,
+            },
+        ]);
+        if (!collateral || !quote)
+            throw new Error("Failed to fetch tokens");
+        const market = `${params.symbolQuoteToken}/${collateral?.symbol}`;
+        const subtypes = [
+            { name: `Supply ${collateral?.symbol} on ${market}`, action: OpportunityAction.LEND },
+            { name: `Borrow ${quote?.symbol} on ${market}`, action: OpportunityAction.BORROW },
+        ];
+        const subtype = subtypes[campaignSubType];
+        return {
+            action: subtype.action,
+            name: subtype.name,
+            tokens: [
+                { chainId, address: collateral.address },
+                { chainId, address: quote.address },
+            ],
+            mainProtocol: "ajna",
+        };
+    }
+    catch (_err) {
+        const market = `${params.symbolQuoteToken}/${params.symbolCollateralToken}`;
+        const subtypes = [
+            { name: `Supply ${params.symbolCollateralToken} on ${market}`, action: OpportunityAction.LEND },
+            { name: `Borrow ${params.symbolQuoteToken} on ${market}`, action: OpportunityAction.BORROW },
+        ];
+        const subtype = subtypes[campaignSubType];
+        return {
+            action: subtype.action,
+            name: subtype.name,
+            tokens: [
+                { chainId, address: params.collateralToken },
+                { chainId, address: params.quoteToken },
+            ],
+            mainProtocol: "ajna",
+        };
+    }
+};

package/dist/src/modules/v4/opportunity/subservices/getBadgerMetadata.service.js

@@ -0,0 +1,23 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+import { TokenService } from "../../token";
+export const getBadgerMetadata = async (chainId, params) => {
+    try {
+        const [token] = await TokenService.getManyOrCreate([{ chainId, address: params.targetToken }]);
+        if (!token)
+            throw new Error("Failed to fetch tokens");
+        return {
+            action: OpportunityAction.BORROW,
+            name: `Borrow ${token.symbol}`,
+            tokens: [{ chainId, address: token?.address }],
+            mainProtocol: "badger",
+        };
+    }
+    catch (err) {
+        return {
+            action: OpportunityAction.BORROW,
+            name: `Borrow ${params.symbolTargetToken}`,
+            tokens: [{ chainId, address: params.targetToken }],
+            mainProtocol: "badger",
+        };
+    }
+};

package/dist/src/modules/v4/opportunity/subservices/getClammMetadata.service.js

@@ -0,0 +1,33 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+import { ChainId, ammName } from "@sdk";
+import { ProtocolService } from "../../protocol";
+export const getClammMetadata = (chainId, params) => {
+    let platform = ammName(params.amm);
+    if (platform === "BaseSwap") {
+        switch (chainId) {
+            case ChainId.MODE:
+                platform = "SwapMode";
+                break;
+            case ChainId.ARBITRUM:
+                platform = "Arbitex";
+                break;
+            case ChainId.OPTIMISM:
+                platform = "SuperSwap";
+        }
+    }
+    if (platform === "Izumi") {
+        if (chainId === ChainId.ROOTSTOCK)
+            platform = "WoodSwap";
+        else
+            platform = "iZUMi";
+    }
+    return {
+        name: [platform, `${params.symbolToken0}/${params.symbolToken1}`, params.poolFee && `${params.poolFee}%`].join(" "),
+        action: OpportunityAction.POOL,
+        tokens: [
+            { chainId, address: params.token0 },
+            { chainId, address: params.token1 },
+        ],
+        mainProtocol: ProtocolService.getIdFromAmmV3(params.amm),
+    };
+};

package/dist/src/modules/v4/opportunity/subservices/getCompoundMetadata.service.js

@@ -0,0 +1,18 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+import { CompFork, CompoundSubCampaignType } from "@sdk";
+export const getCompoundMetadata = (chainId, campaignSubType, params) => {
+    return {
+        action: campaignSubType === CompoundSubCampaignType.supply ? OpportunityAction.LEND : OpportunityAction.BORROW,
+        name: [
+            CompFork[params.compFork],
+            params.subCampaignType === CompoundSubCampaignType.supply
+                ? `Supply ${params.symbolTargetToken}`
+                : `Borrow ${params.symbolTargetToken}`,
+        ].join(" "),
+        tokens: [
+            { chainId, address: params.underlyingToken },
+            { chainId, address: params.targetToken },
+        ],
+        mainProtocol: "compound",
+    };
+};

package/dist/src/modules/v4/opportunity/subservices/getDolomiteMetadata.service.js

@@ -0,0 +1,15 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+export const getDolomiteMetadata = (chainId, campaignSubType, params) => {
+    const subtypes = [
+        { name: "Delta", action: OpportunityAction.LEND },
+        { name: "Supply", action: OpportunityAction.LEND },
+        { name: "Borrow", action: OpportunityAction.BORROW },
+    ];
+    const subtype = subtypes[campaignSubType];
+    return {
+        action: subtype.action,
+        tokens: [{ chainId, address: params.targetToken }],
+        name: `${subtype.name} ${params.symbolTargetToken}`,
+        mainProtocol: "dolomite",
+    };
+};

package/dist/src/modules/v4/opportunity/subservices/getErc20Metadata.service.js

@@ -0,0 +1,63 @@
+import { log } from "../../../../utils/logger";
+import { CampaignType } from "../../../../../database/api/.generated";
+import { CampaignService } from "../../campaign";
+export const getErc20Metadata = async (chainId, campaignId, rewardToken, amount, params) => {
+    let action = "HOLD";
+    let name = `Hold ${params.symbolTargetToken}`;
+    try {
+        const [dynamicData] = await CampaignService.fetchDynamicData(chainId, CampaignType.ERC20, [
+            {
+                campaignId,
+                rewardToken,
+                amount,
+                campaignParameters: params,
+            },
+        ]);
+        const map = {
+            actions: {
+                POOL: [
+                    "uniswapv2",
+                    "velodrome",
+                    "aerodrome",
+                    "balancerGauge",
+                    "balancerPool",
+                    "curve",
+                    "aura",
+                    "akron",
+                    "beefy",
+                    "dragonswap",
+                    "poolside",
+                    "koi",
+                ],
+                BORROW: ["radiant_borrow", "aave_borrowing", "euler_borrow"],
+                LEND: [
+                    "gearbox",
+                    "compound",
+                    "radiant_lend",
+                    "aave_lending",
+                    "sturdy_aggregator",
+                    "sturdy_silo",
+                    "fraxlend",
+                    "moonwell",
+                    "ionic",
+                    "fluid",
+                    "silostaking",
+                    "euler_lend",
+                    "layerbank",
+                ],
+            },
+        };
+        action =
+            Object.entries(map.actions).find(([_action, _types]) => _types.includes(dynamicData?.type ?? ""))?.[0] ?? "HOLD";
+        //TODO: /!\ fix this "as any"
+        name = dynamicData?.typeInfo?.cardName;
+    }
+    catch {
+        log.warn(`failed to fetch dynamic data for ERC20 campaign ${campaignId}`);
+    }
+    return {
+        action,
+        name,
+        tokens: [{ chainId, address: params.targetToken }],
+    };
+};

package/dist/src/modules/v4/opportunity/subservices/getErc20SnapshotMetadata.service.js

@@ -0,0 +1,8 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+export const getErc20SnapshotMetadata = (chainId, params) => {
+    return {
+        name: ["Airdrop", params.symbolTargetToken, "holders"].join(" "),
+        action: OpportunityAction.DROP,
+        tokens: [{ chainId, address: params.targetToken }],
+    };
+};

package/dist/src/modules/v4/opportunity/subservices/getEulerMetadata.service.js

@@ -0,0 +1,30 @@
+import { log } from "../../../../utils/logger";
+import { CampaignType, OpportunityAction } from "../../../../../database/api/.generated";
+import { CampaignService } from "../../campaign";
+export const getEulerMetadata = async (chainId, campaignId, campaignSubType, rewardToken, amount, params
+// campaign: CampaignParameters<ConvertedCampaignType<"EULER">>
+) => {
+    let name = `Hold ${params.symbolTargetToken}`;
+    try {
+        const [dynamicData] = await CampaignService.fetchDynamicData(chainId, CampaignType.EULER, [
+            {
+                campaignSubType,
+                campaignParameters: params,
+                computeChainId: chainId,
+                campaignId,
+                rewardToken,
+                amount,
+            },
+        ]);
+        name = dynamicData?.typeInfo?.cardName;
+    }
+    catch {
+        log.warn(`failed to fetch dynamic data for ERC20 campaign ${campaignId}`);
+    }
+    return {
+        name,
+        tokens: [{ chainId, address: params.targetToken }],
+        action: [OpportunityAction.LEND, OpportunityAction.BORROW, OpportunityAction.BORROW][campaignSubType],
+        mainProtocol: "euler",
+    };
+};

package/dist/src/modules/v4/opportunity/subservices/getJsonAirDropMetadata.service.js

@@ -0,0 +1,36 @@
+import { log } from "../../../../utils/logger";
+import { OpportunityAction } from "../../../../../database/api/.generated";
+export const getJsonAirdropMetadata = async (chainId, creator, params) => {
+    const ACI = "0xdeadD8aB03075b7FBA81864202a2f59EE25B312b".toLowerCase();
+    const aaveDAO = "0x5300A1a15135EA4dc7aD5a167152C01EFc9b192A".toLowerCase();
+    const aciPrefix = creator.toLowerCase() === ACI && "Aave Merit Rewards -";
+    const aavePrefix = creator.toLowerCase() === aaveDAO && "Aave - aAMPL distribution -";
+    const prefix = aavePrefix ? aavePrefix : aciPrefix ? aciPrefix : "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,
+                    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/modules/v4/opportunity/subservices/getMorphoMetadata.service.js

@@ -0,0 +1,19 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+import { BN2Number } from "@sdk";
+export const getMorphoMetadata = (chainId, campaignSubType, params) => {
+    const morphoParams = params;
+    const market = `${morphoParams.symbolLoanToken}/${morphoParams.symbolBorrowToken} ${morphoParams?.LLTV && BN2Number(morphoParams?.LLTV, 16)}%`;
+    const subtypes = [
+        { name: `Metamorpho ${morphoParams.nameTargetToken}`, action: OpportunityAction.LEND },
+        { name: `Supply ${morphoParams.symbolLoanToken} on ${market}`, action: OpportunityAction.LEND },
+        { name: `Borrow ${morphoParams.symbolLoanToken} on ${market}`, action: OpportunityAction.BORROW },
+        { name: `Collateral ${morphoParams.symbolBorrowToken} on ${market}`, action: OpportunityAction.LEND },
+    ];
+    const subtype = subtypes[campaignSubType];
+    return {
+        action: subtype.action,
+        tokens: [{ chainId, address: params.targetToken }],
+        name: subtype.name,
+        mainProtocol: "morpho",
+    };
+};

package/dist/src/modules/v4/opportunity/subservices/getRadiantMetadata.service.js

@@ -0,0 +1,9 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+export const getRadiantMetadata = (chainId, campaignSubType, params) => {
+    return {
+        action: campaignSubType <= 1 ? OpportunityAction.LEND : OpportunityAction.BORROW,
+        name: ["Radiant", params.symbolTargetToken].join(" "),
+        tokens: [{ chainId, address: params.targetToken }],
+        mainProtocol: "radiant",
+    };
+};

package/dist/src/modules/v4/opportunity/subservices/getSiloMetadata.service.js

@@ -0,0 +1,13 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+export const getSiloMetadata = (chainId, campaignSubType, params) => {
+    let suffix = ["Deposit", "Protected Deposit", "Debt"][campaignSubType];
+    const assetSymbol = params.symbolTargetToken;
+    if (params.forwarders.length === 1 && assetSymbol)
+        suffix += ` (${assetSymbol} Market)`;
+    return {
+        action: campaignSubType <= 1 ? OpportunityAction.LEND : OpportunityAction.BORROW,
+        name: ["Silo", params.symbolTargetToken, suffix].join(" "),
+        tokens: [{ chainId, address: params.targetToken }],
+        mainProtocol: "silo",
+    };
+};

package/dist/src/modules/v4/opportunity/transform-id.pipe.js

@@ -0,0 +1,6 @@
+import { CampaignService } from "../campaign";
+export function transformId({ params }) {
+    const [chainId, type, campaignId] = params.id.split("-");
+    if (!Number.isNaN(+type))
+        params.id = `${chainId}-${CampaignService.getTypeFromV3(+type)}-${campaignId}`;
+}

package/dist/src/modules/v4/opportunity/validate-id.pipe.js

@@ -0,0 +1,12 @@
+import { BadRequestError } from "../../../errors";
+import { CampaignType } from "../../../../database/api/.generated";
+export const validateId = ({ params }) => {
+    if (!params.id.includes("-")) {
+        if (/[0-9]{1,20}/.test(params.id))
+            return;
+        throw new BadRequestError("Invalid Opportunity id");
+    }
+    const [_chainId, type, _campaignId] = params.id.split("-");
+    if (!Object.values(CampaignType).includes(type))
+        throw new BadRequestError("Invalid Campaign type", Object.values(CampaignType));
+};

package/dist/src/modules/v4/participate/participate.controller.js

@@ -0,0 +1,66 @@
+import Elysia from "elysia";
+import { EnsoService } from "../enso/enso.service";
+import { GetParticipateProtocolsQueryDto, GetParticipateQuoteQueryDto, GetParticipateTargetsQueryDto, } from "./participate.model";
+import { ParticipateService } from "./participate.service";
+// ─── Participate Controller ──────────────────────────────────────────────────
+export const ParticipateController = new Elysia({ prefix: "/participate", detail: { tags: ["Participate"] } })
+    .get("/targets", async ({ query: { protocolId, chainId, identifier } }) => {
+    if (identifier)
+        return await ParticipateService.getTarget(chainId, protocolId, identifier);
+    return await ParticipateService.getTargets(chainId, protocolId);
+}, {
+    query: GetParticipateTargetsQueryDto,
+    detail: {
+        summary: "Available interaction targets for a protocol",
+        description: "Retrieves all the pool/token/contract",
+    },
+})
+    .get("/protocols", async ({ query }) => {
+    return await EnsoService.getCompatibleProtocols(query);
+}, {
+    query: GetParticipateProtocolsQueryDto,
+    detail: {
+        summary: "Interactable protocols",
+        description: "Retrieves protocols integrated by merkl which supports being interacted with",
+    },
+})
+    .get("/quote", async ({ query: { protocolId, chainId, identifier, userAddress, fromAmount, fromTokenAddress } }) => {
+    const [target] = (await ParticipateService.getTarget(chainId, protocolId, identifier)) ?? [];
+    //TODO: throw error
+    if (!target)
+        return;
+    return await EnsoService.getQuote({
+        fromAddress: userAddress,
+        tokenIn: [fromTokenAddress],
+        tokenOut: [target.identifier],
+        amountIn: [fromAmount],
+        routingStrategy: "router",
+        chainId,
+    });
+}, {
+    query: GetParticipateQuoteQueryDto,
+    detail: {
+        summary: "Preview participate transaction",
+        description: "",
+    },
+})
+    .get("/transaction", async ({ query: { protocolId, chainId, identifier, userAddress, fromAmount, fromTokenAddress } }) => {
+    const [target] = (await ParticipateService.getTarget(chainId, protocolId, identifier)) ?? [];
+    //TODO: throw error
+    if (!target)
+        return;
+    return await EnsoService.getTransaction({
+        fromAddress: userAddress,
+        tokenIn: [fromTokenAddress],
+        tokenOut: [target.identifier],
+        amountIn: [fromAmount],
+        routingStrategy: "router",
+        chainId,
+    });
+}, {
+    query: GetParticipateQuoteQueryDto,
+    detail: {
+        summary: "Get participate transaction",
+        description: "",
+    },
+});

package/dist/src/modules/v4/participate/participate.model.js

@@ -0,0 +1,24 @@
+import protocol from "database/api/seeder/resources/protocol";
+import { t } from "elysia";
+export const participateInputTypes = ["tokenAmount", "token"];
+export const participateTypes = ["link", "deposit", "withdraw"];
+export const GetParticipateTargetsQueryDto = t.Object({
+    chainId: t.Numeric(),
+    protocolId: t.String({
+        examples: Object.values(protocol).reduce((obj, i) => Object.assign(obj, { [i.name]: { value: i.id } }), {}),
+    }),
+    identifier: t.Optional(t.String()),
+});
+export const GetParticipateQuoteQueryDto = t.Object({
+    chainId: t.Numeric(),
+    protocolId: t.String({
+        examples: Object.values(protocol).reduce((obj, i) => Object.assign(obj, { [i.name]: { value: i.id } }), {}),
+    }),
+    identifier: t.String(),
+    userAddress: t.String(),
+    fromTokenAddress: t.String(),
+    fromAmount: t.String(),
+});
+export const GetParticipateProtocolsQueryDto = t.Object({
+    chainId: t.Optional(t.Numeric()),
+});

package/dist/src/modules/v4/participate/participate.service.js

@@ -0,0 +1,33 @@
+import { EnsoService } from "../enso/enso.service";
+import { TokenService } from "../token";
+export class ParticipateService {
+    static async getTarget(chainId, protocolId, identifier) {
+        const slug = EnsoService.getSlug(protocolId);
+        if (!slug)
+            return;
+        const tokens = await EnsoService.getTokens(chainId, slug, identifier);
+        return await ParticipateService.getTargetsFromEnsoTokens(tokens);
+    }
+    static async getTargetsFromEnsoTokens(tokens) {
+        const targets = [];
+        for (const { address, underlyingTokens, ...target } of tokens) {
+            try {
+                const [utilityToken, ...assetTokens] = await TokenService.getManyOrCreate([{ chainId: target.chainId, address }].concat(underlyingTokens));
+                targets.push({
+                    identifier: address,
+                    name: `${utilityToken?.symbol}: ${assetTokens.map(t => t?.symbol).join("/")}`,
+                    tokens: assetTokens.filter(t => t !== undefined),
+                });
+            }
+            catch { }
+        }
+        return targets;
+    }
+    static async getTargets(chainId, protocolId) {
+        const slug = EnsoService.getSlug(protocolId);
+        if (!slug)
+            return;
+        const tokens = await EnsoService.getTokens(chainId, slug);
+        return await ParticipateService.getTargetsFromEnsoTokens(tokens);
+    }
+}

package/dist/src/modules/v4/price/index.js

@@ -0,0 +1,3 @@
+export * from "./price.controller";
+export * from "./price.service";
+export * from "./price.model";