@merkl/api 0.10.199 → 0.10.200

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

@@ -1,323 +1,22 @@
-import { BN2Number, ERC20Interface } from "@sdk";
-import { tokenType } from "./helpers/tokenType";
-import { eulerInterface, fluidInterface, torosInterface } from "./subtypesRound1";
-import { balancerVaultInterface } from "./subtypesRound3";
+import { processorMapping } from "./processor/processorMapping";
 export function getTokenTypeRound4(index, type, typeInfo, calls, campaign) {
-    const blacklistedLiquidityCalls = [];
-    if (campaign.campaignParameters.blacklist.length > 0) {
-        for (const blacklistedAddress of campaign.campaignParameters.blacklist) {
-            blacklistedLiquidityCalls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("balanceOf", [blacklistedAddress]),
-                target: typeInfo.tokenAddress,
-            });
+    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);
     }
-    const whitelistedLiquidityCalls = [];
-    if (campaign.campaignParameters.whitelist.length > 0) {
-        for (const whitelistedAddress of campaign.campaignParameters.whitelist) {
-            whitelistedLiquidityCalls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("balanceOf", [whitelistedAddress]),
-                target: typeInfo.tokenAddress,
-            });
-        }
-    }
-    if (type === tokenType.uniswapv2 ||
-        type === tokenType.poolside ||
-        type === tokenType.aerodrome ||
-        type === tokenType.velodrome ||
-        type === tokenType.dragonswap ||
-        type === tokenType.akron) {
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: typeInfo.tokenAddress,
-                },
-            ].concat(blacklistedLiquidityCalls),
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-    if (type === tokenType.balancerGauge) {
-        const tokens = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[0];
-        const balances = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[1];
-        let i = 0;
-        const poolTokens = [];
-        for (const token of tokens) {
-            poolTokens.push({
-                token: token,
-                balance: balances[i].toString(),
-            });
-            i++;
-        }
-        const poolCalls = [
-            {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                target: typeInfo.tokenAddress,
-            },
-        ];
-        for (const poolToken of poolTokens) {
-            poolCalls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("symbol"),
-                target: poolToken.token,
-            });
-            poolCalls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("decimals"),
-                target: poolToken.token,
-            });
-        }
-        return {
-            type: tokenType.balancerGauge,
-            calls: poolCalls.concat(blacklistedLiquidityCalls),
-            typeInfo: {
-                ...typeInfo,
-                poolTokens: poolTokens,
-            },
-        };
-    }
-    // symbol is ECLP-USDC-USDT
-    if (type === tokenType.balancerPool) {
-        const tokens = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[0];
-        const balances = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[1];
-        let i = 0;
-        const poolTokens = [];
-        for (const token of tokens) {
-            if (token !== typeInfo.tokenAddress) {
-                poolTokens.push({
-                    token: token,
-                    balance: balances[i].toString(),
-                });
-            }
-            i++;
-        }
-        const poolCalls = [
-            {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                target: typeInfo.tokenAddress,
-            },
-        ];
-        for (const poolToken of poolTokens) {
-            poolCalls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("symbol"),
-                target: poolToken.token,
-            });
-            poolCalls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("decimals"),
-                target: poolToken.token,
-            });
-        }
-        poolCalls.push({
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("balanceOf", [typeInfo.vault]),
-            target: typeInfo.tokenAddress,
-        });
-        return {
-            type: tokenType.balancerPool,
-            calls: poolCalls.concat(blacklistedLiquidityCalls),
-            typeInfo: {
-                ...typeInfo,
-                poolTokens: poolTokens,
-            },
-        };
-    }
-    if (type === tokenType.aura) {
-        const tokens = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[0];
-        const balances = balancerVaultInterface.decodeFunctionResult("getPoolTokens", calls[index].returnData)[1];
-        let i = 0;
-        const poolTokens = [];
-        for (const token of tokens) {
-            if (token !== typeInfo.tokenAddress) {
-                poolTokens.push({
-                    token: token,
-                    balance: balances[i].toString(),
-                });
-            }
-            i++;
-        }
-        const poolCalls = [
-            {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                target: typeInfo.tokenAddress,
-            },
-        ];
-        for (const poolToken of poolTokens) {
-            poolCalls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("symbol"),
-                target: poolToken.token,
-            });
-            poolCalls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("decimals"),
-                target: poolToken.token,
-            });
-        }
-        const gaugeBalance = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 1].returnData)[0];
-        const auraBalance = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 2].returnData)[0];
-        const totalSupplyGauge = ERC20Interface.decodeFunctionResult("totalSupply", calls[index + 3].returnData)[0];
+    catch (error) {
+        console.error(error);
         return {
             type: type,
-            calls: poolCalls.concat(blacklistedLiquidityCalls),
+            calls: [],
             typeInfo: {
                 ...typeInfo,
-                poolTokens: poolTokens,
-                gaugeBalance: BN2Number(gaugeBalance, 18),
-                auraBalance: BN2Number(auraBalance, 18),
-                totalSupplyGauge: BN2Number(totalSupplyGauge, 18),
             },
         };
     }
-    if (type === tokenType.gearbox) {
-        // Get the underlying gearbox token to fetch the final underlying token
-        const decimalsUnderlyingToken = ERC20Interface.decodeFunctionResult("decimals", calls[index].returnData)[0];
-        const symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index + 1].returnData)[0];
-        const totalAssets = BN2Number(typeInfo.totalAssets, decimalsUnderlyingToken);
-        return {
-            type: tokenType.gearbox,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: typeInfo.tokenAddress,
-                },
-            ].concat(blacklistedLiquidityCalls),
-            typeInfo: {
-                ...typeInfo,
-                decimalsUnderlyingToken,
-                symbolUnderlyingToken,
-                totalAssets: totalAssets,
-            },
-        };
-    }
-    if (type === tokenType.toros) {
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: typeInfo.tokenAddress,
-                },
-                {
-                    allowFailure: true,
-                    callData: torosInterface.encodeFunctionData("tokenPrice"),
-                    target: typeInfo.tokenAddress,
-                },
-            ].concat(blacklistedLiquidityCalls),
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-    if (type === tokenType.fluid) {
-        const toAssets = fluidInterface.decodeFunctionResult("convertToAssets", calls[index].returnData)[0];
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: typeInfo.tokenAddress,
-                },
-            ].concat(blacklistedLiquidityCalls),
-            typeInfo: {
-                ...typeInfo,
-                exchangeRate: BN2Number(toAssets, typeInfo.decimalsUnderlyingToken),
-            },
-        };
-    }
-    if (type === tokenType.euler_lend || type === tokenType.euler_borrow) {
-        const decimalsUnderlyingToken = ERC20Interface.decodeFunctionResult("decimals", calls[index].returnData)[0];
-        const symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index + 1].returnData)[0];
-        let call;
-        if (type === tokenType.euler_lend) {
-            call = {
-                allowFailure: true,
-                callData: eulerInterface.encodeFunctionData("totalAssets"),
-                target: typeInfo.tokenAddress,
-            };
-        }
-        else {
-            call = {
-                allowFailure: true,
-                callData: eulerInterface.encodeFunctionData("totalBorrows"),
-                target: typeInfo.vault,
-            };
-        }
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: typeInfo.tokenAddress,
-                },
-                call,
-            ].concat(blacklistedLiquidityCalls),
-            typeInfo: {
-                ...typeInfo,
-                decimalsUnderlyingToken: decimalsUnderlyingToken,
-                symbolUnderlyingToken: symbolUnderlyingToken,
-            },
-        };
-    }
-    if (type === tokenType.beefy) {
-        const symbolToken0 = ERC20Interface.decodeFunctionResult("symbol", calls[index].returnData)[0];
-        const symbolToken1 = ERC20Interface.decodeFunctionResult("symbol", calls[index + 1].returnData)[0];
-        const decimalsToken0 = ERC20Interface.decodeFunctionResult("decimals", calls[index + 2].returnData)[0];
-        const decimalsToken1 = ERC20Interface.decodeFunctionResult("decimals", calls[index + 3].returnData)[0];
-        const balanceToken0 = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 4].returnData)[0];
-        const balanceToken1 = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 5].returnData)[0];
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: typeInfo.underlyingToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: typeInfo.tokenAddress,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                symbolToken0,
-                symbolToken1,
-                decimalsToken0,
-                decimalsToken1,
-                balanceToken0: BN2Number(balanceToken0, decimalsToken0),
-                balanceToken1: BN2Number(balanceToken1, decimalsToken1),
-            },
-        };
-    }
-    return {
-        type: type,
-        calls: [
-            {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                target: typeInfo.tokenAddress,
-            },
-        ]
-            .concat(blacklistedLiquidityCalls)
-            .concat(whitelistedLiquidityCalls),
-        typeInfo: {
-            ...typeInfo,
-        },
-    };
 }

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

@@ -1,11 +1,11 @@
-import { BN2Number, ERC20Interface, EulerSubCampaignType, YEAR, } from "@sdk";
+import { BN2Number, BalancerPoolInterface, ERC20Interface, EnzymeInterface, EulerSubCampaignType, FactoryInterface, MetamorphoInterface, YEAR, } from "@sdk";
 import { batchMulticallCallWithRetry } from "../../../utils/generic";
 import { Pricer } from "../../../utils/pricer";
 import { fetchEulerVaultName } from "./ERC20SubTypes/helpers/eulerVaultNames";
 import { tokenType } from "./ERC20SubTypes/helpers/tokenType";
 import { getTokenPricesInfo } from "./ERC20SubTypes/subtypesPrices";
-import { enzymeInterface, factoryInterface, getTokenTypeRound1, metamorphoInterface, } from "./ERC20SubTypes/subtypesRound1";
-import { balancerPoolInterface, getTokenTypeRound2 } from "./ERC20SubTypes/subtypesRound2";
+import { getTokenTypeRound1 } from "./ERC20SubTypes/subtypesRound1";
+import { getTokenTypeRound2 } from "./ERC20SubTypes/subtypesRound2";
 import { getTokenTypeRound3 } from "./ERC20SubTypes/subtypesRound3";
 import { getTokenTypeRound4 } from "./ERC20SubTypes/subtypesRound4";
 export async function EulerDynamicData(chainId, campaigns) {
@@ -15,12 +15,12 @@ export async function EulerDynamicData(chainId, campaigns) {
     for (const campaign of campaigns) {
         callsRounds1.push({
             allowFailure: true,
-            callData: factoryInterface.encodeFunctionData("factory"),
+            callData: FactoryInterface.encodeFunctionData("factory"),
             target: campaign.campaignParameters.targetToken,
         });
         callsRounds1.push({
             allowFailure: true,
-            callData: metamorphoInterface.encodeFunctionData("MORPHO"),
+            callData: MetamorphoInterface.encodeFunctionData("MORPHO"),
             target: campaign.campaignParameters.targetToken,
         });
         callsRounds1.push({
@@ -30,12 +30,12 @@ export async function EulerDynamicData(chainId, campaigns) {
         });
         callsRounds1.push({
             allowFailure: true,
-            callData: balancerPoolInterface.encodeFunctionData("getPoolId"),
+            callData: BalancerPoolInterface.encodeFunctionData("getPoolId"),
             target: campaign.campaignParameters.targetToken,
         });
         callsRounds1.push({
             allowFailure: true,
-            callData: enzymeInterface.encodeFunctionData("getCreator"),
+            callData: EnzymeInterface.encodeFunctionData("getCreator"),
             target: campaign.campaignParameters.targetToken,
         });
     }
@@ -52,7 +52,7 @@ export async function EulerDynamicData(chainId, campaigns) {
             calls: [],
             typeInfo: {},
         };
-        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i);
+        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i, campaign);
         i += 5;
         tokenTypesByCampaign[campaign.campaignId] = typeStruct;
         callsRounds2.push(...typeStruct.calls);

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

@@ -1,12 +1,11 @@
 import { engineDbClient } from "../../../utils/prisma";
-import { BN2Number, ERC20Interface, NULL_ADDRESS, RadiantPoolInterface, YEAR, } from "@sdk";
+import { BN2Number, ERC20Interface, NULL_ADDRESS, RadiantInterface, RadiantPoolInterface, YEAR, } from "@sdk";
 import { Contract } from "ethers";
 import { log } from "../../../utils/logger";
 import { Pricer } from "../../../utils/pricer";
 import { providers } from "../../../utils/providers";
 import { merklChainDataWithCache } from "../../merklChainData";
 import { getLastEligibilityRatio } from "../utils/getLastEligibilityRatio";
-import { radiantInterface } from "./ERC20SubTypes/subtypesRound1";
 export async function RadiantDynamicData(chainId, campaigns) {
     const pricer = await Pricer.load();
     const calls = [];
@@ -24,7 +23,7 @@ export async function RadiantDynamicData(chainId, campaigns) {
         });
         calls.push({
             allowFailure: true,
-            callData: radiantInterface.encodeFunctionData("getAssetPrice"),
+            callData: RadiantInterface.encodeFunctionData("getAssetPrice"),
             target: campaign.campaignParameters.targetToken,
         });
     }
@@ -79,7 +78,7 @@ export async function RadiantDynamicData(chainId, campaigns) {
                     i++;
                     let priceTargetToken = 0;
                     try {
-                        priceTargetToken = BN2Number(radiantInterface.decodeFunctionResult("getAssetPrice", result[i])[0], priceDecimals);
+                        priceTargetToken = BN2Number(RadiantInterface.decodeFunctionResult("getAssetPrice", result[i])[0], priceDecimals);
                     }
                     catch (e) {
                         log.local("Error getting priceTargetToken");

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

@@ -7,7 +7,6 @@ import { CLAMMDynamicData } from "./campaignTypes/CLAMMDynamicData";
 import { CompoundDynamicData } from "./campaignTypes/CompoundDynamicData";
 import { DolomiteDynamicData } from "./campaignTypes/DolomiteDynamicData";
 import { ERC20DynamicData } from "./campaignTypes/ERC20DynamicData";
-import { ERC20DynamicDataRefacto } from "./campaignTypes/ERC20DynamicDataRefacto";
 import { ERC20_SNAPSHOTDynamicData } from "./campaignTypes/ERC20_SNAPSHOTDynamicData";
 import { EulerDynamicData } from "./campaignTypes/EulerDynamicData";
 import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData";
@@ -27,10 +26,6 @@ export async function campaignsDynamicData(chainId, campaigns, type) {
     catch (_err) { }
     switch (type) {
         case Campaign.ERC20: {
-            const switchRefacto = process.env.SWITCH_REFACTO_SUBTYPES_ERC20 !== undefined ? process.env.SWITCH_REFACTO_SUBTYPES_ERC20 : false;
-            if (switchRefacto) {
-                return ERC20DynamicDataRefacto(chainId, campaigns);
-            }
             return ERC20DynamicData(chainId, campaigns);
         }
         case Campaign.CLAMM: {

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

@@ -2,7 +2,7 @@ import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOf
 import { AccountingService, ChainDto, DateDto, GetTransactionsQueryModel, RevenuesDto, TokensDateDto, TokensDto, } from "./";
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../../utils/throw";
 import Elysia from "elysia";
-export const AccountingController = new Elysia({ prefix: "/accounting", detail: { tags: ["Accounting"] } })
+export const AccountingController = new Elysia({ prefix: "/accounting", detail: { tags: ["Accounting"], hide: true } })
     .get("/", async ({ query }) => await AccountingService.getMany(query), {
     query: GetTransactionsQueryModel,
     headers: AuthorizationHeadersDto,

package/dist/src/modules/v4/apr/apr.model.d.ts

@@ -13,3 +13,29 @@ export type AprRecord = Resource<"AprRecord", "id" | "opportunityId", {
  * @see {@link Resource}
  */
 export type AprBreakdown = Resource<"AprBreakdown", "id" | "aprRecordId">;
+export declare const AprBreakdownResourceDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TNumber;
+    type: import("@sinclair/typebox").TEnum<{
+        CAMPAIGN: "CAMPAIGN";
+        TOKEN: "TOKEN";
+        PROTOCOL: "PROTOCOL";
+    }>;
+    identifier: import("@sinclair/typebox").TString;
+    value: import("@sinclair/typebox").TNumber;
+    aprRecordId: import("@sinclair/typebox").TString;
+}>;
+export declare const AprRecordResourceDto: import("@sinclair/typebox").TObject<{
+    cumulated: import("@sinclair/typebox").TNumber;
+    timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
+    breakdowns: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TNumber;
+        type: import("@sinclair/typebox").TEnum<{
+            CAMPAIGN: "CAMPAIGN";
+            TOKEN: "TOKEN";
+            PROTOCOL: "PROTOCOL";
+        }>;
+        identifier: import("@sinclair/typebox").TString;
+        value: import("@sinclair/typebox").TNumber;
+        aprRecordId: import("@sinclair/typebox").TString;
+    }>>;
+}>;

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

@@ -1 +1,15 @@
-export {};
+import { AprType } from "../../../../database/api/.generated";
+import { t } from "elysia";
+// ─── Dtos ────────────────────────────────────────────────────────────────────
+export const AprBreakdownResourceDto = t.Object({
+    id: t.Number(),
+    type: t.Enum(AprType),
+    identifier: t.String(),
+    value: t.Number(),
+    aprRecordId: t.String(),
+});
+export const AprRecordResourceDto = t.Object({
+    cumulated: t.Number(),
+    timestamp: t.Union([t.BigInt(), t.String()]),
+    breakdowns: t.Array(AprBreakdownResourceDto),
+});

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

@@ -4,7 +4,7 @@ import { NULL_ADDRESS } from "@sdk";
 import Elysia from "elysia";
 import { AddBlacklistDto, CheckBlacklistDto, RemoveBlacklistDto } from "./blacklist.model";
 import { BlacklistService } from "./blacklist.service";
-export const BlacklistController = new Elysia({ prefix: "/blacklists", detail: { tags: ["Blacklists"] } })
+export const BlacklistController = new Elysia({ prefix: "/blacklists", detail: { tags: ["Blacklists"], hide: true } })
     // ─── Get Entire Blacklist ────────────────────────────────────────────
     .get("/", async () => await BlacklistService.findMany())
     .get("/mapping", async () => await BlacklistService.findMapping())

package/dist/src/modules/v4/campaign/campaign.controller.d.ts

@@ -20,13 +20,13 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                     subType?: number | undefined;
                     type: number;
                     params: string;
+                    creator: string;
                     chainId: number;
                     startTimestamp: string;
                     endTimestamp: string;
                     computeChainId: number;
                     campaignId: string;
                     amount: string;
-                    creator: string;
                     rewardTokenAddress: string;
                     opportunityIdentifier: string;
                 };
@@ -63,11 +63,11 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                     type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
                     items?: number | undefined;
                     subType?: number | undefined;
+                    page?: number | undefined;
                     chainId?: number | undefined;
                     startTimestamp?: string | undefined;
                     endTimestamp?: string | undefined;
                     tokenAddress?: string | undefined;
-                    page?: number | undefined;
                     mainParameter?: string | undefined;
                     campaignId?: string | undefined;
                     opportunityId?: string | undefined;
@@ -87,9 +87,9 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                             symbol: string;
                             name: string | null;
                             id: string;
+                            icon: string;
                             chainId: number;
                             address: string;
-                            icon: string;
                             decimals: number;
                             verified: boolean;
                             isTest: boolean;
@@ -134,11 +134,11 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                     type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
                     items?: number | undefined;
                     subType?: number | undefined;
+                    page?: number | undefined;
                     chainId?: number | undefined;
                     startTimestamp?: string | undefined;
                     endTimestamp?: string | undefined;
                     tokenAddress?: string | undefined;
-                    page?: number | undefined;
                     mainParameter?: string | undefined;
                     campaignId?: string | undefined;
                     opportunityId?: string | undefined;

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

@@ -1,8 +1,8 @@
 import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.guard";
-import Elysia from "elysia";
+import Elysia, { t } from "elysia";
 import { throwOnUnsupportedChainId } from "src/utils/throw";
 import { ChainUniqueDto } from "../chain";
-import { CreateCampaignDto, GetCampaignQueryDto } from "./campaign.model";
+import { CampaignResourceDto, CreateCampaignDto, GetCampaignQueryDto } from "./campaign.model";
 import { CampaignService } from "./campaign.service";
 // ─── Campaigns Controller ────────────────────────────────────────────────────
 export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { tags: ["Campaigns"] } })
@@ -14,9 +14,17 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
     detail: { hide: true },
 })
     // ─── Get Many Campaigns ──────────────────────────────────────────────
-    .get("/", async ({ query }) => await CampaignService.findMany(query), { query: GetCampaignQueryDto })
+    .get("/", async ({ query }) => await CampaignService.findMany(query), {
+    query: GetCampaignQueryDto,
+    response: t.Array(CampaignResourceDto),
+    detail: `**Retrieve Multiple Campaigns**
+      <p>This endpoint enables you to search for opportunities by providing specific criteria through query parameters.</p>`,
+})
     // ─── Get Total Campaigns Count ───────────────────────────────────────
-    .get("/count", async ({ query }) => await CampaignService.countMany(query), { query: GetCampaignQueryDto })
+    .get("/count", async ({ query }) => await CampaignService.countMany(query), {
+    query: GetCampaignQueryDto,
+    response: t.Number(),
+})
     .group("/campaigns-to-process", app => {
     return (app
         // ─── Get The List Of Campaigns To Process ────
@@ -25,6 +33,7 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
         beforeHandle: ({ query }) => {
             throwOnUnsupportedChainId(query.chainId);
         },
+        detail: { hide: true },
     })
         // ─── Get Count Of CampaignsToProcess ─────────
         .get("/count", async ({ query }) => (await CampaignService.findCampaignsToProcess(query.chainId)).length, {
@@ -32,6 +41,7 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
         beforeHandle: ({ query }) => {
             throwOnUnsupportedChainId(query.chainId);
         },
+        detail: { hide: true },
     })
         // ─── Marks A Campaignid As Processing ────────
         .post("/engine", async ({ query }) => await CampaignService.pickCampaignToProcess(query.chainId), {