@merkl/api 0.10.362 → 0.10.377

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

@@ -14,67 +14,58 @@ export async function ERC20DynamicData(chainId, campaigns) {
     const currentRoot = (await merklChainDataWithCache(chainId)).merkleRoot;
     // Round 1: Get the high level type for each token (will need to be refined lated with more calls)
     const callsRounds1 = [];
-    for (const campaign of campaigns) {
-        // Keep this commented, only use for tests
-        // if (campaign.campaignId === "0xf09492c6d3bd475e269e9f90c92d7e11a671a8fc43470b424ccbb0eea67b762e") {
-        //   // Filament test
-        //   campaign.campaignParameters.targetToken = "0xe855B8018C22A05F84724e93693caf166912aDD5";
-        // }
-        if ([
-            "0xb9bf1ace04e702363bd76b5828ca64a00984af9118672be96c1c200943da941f",
-            "0x1ad188dd597199ca8e6d6a01d5af362769f46bb749da5c08d27eaec4397f53b5",
-        ].includes(campaign.campaignId)) {
-            campaign.campaignParameters.url = "https://moonwell.fi/markets/supply/base/usdc";
-        }
-        if ([
-            "0x2d3ae0a97c6f73ad37c1a9cc5e360f72b206ee61d96952fe772b3ab02f8a5713",
-            "0x653ec2bd4aa79b74a2d6c3240ebe3bc4afb679ea6963c2c8afceef69c7c914f9",
-            "0x6cddb42d99fe4df7d3783f7eb25044bf141084ff99882a2dde931880efc7793d",
-        ].includes(campaign.campaignId)) {
-            campaign.campaignParameters.url =
-                "https://app.zerolend.xyz/reserve-overview/?underlyingAsset=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&marketName=proto_mainnet_rwa_v3&utm_source=Merkle&utm_medium=Website&utm_campaign=MerklMagic30";
-        }
-        callsRounds1.push({
-            allowFailure: true,
-            callData: FactoryInterface.encodeFunctionData("factory"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: true,
-            callData: MetamorphoInterface.encodeFunctionData("MORPHO"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("name"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: true,
-            callData: BalancerPoolInterface.encodeFunctionData("getPoolId"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: true,
-            callData: EnzymeInterface.encodeFunctionData("getCreator"),
-            target: campaign.campaignParameters.targetToken,
-        }, {
-            allowFailure: true,
-            callData: LayerBankERC20Interface.encodeFunctionData("owner"),
-            target: campaign.campaignParameters.targetToken,
-        });
-    }
-    const resultRound1 = await ChainInteractionService(chainId).fetchState(callsRounds1);
     const tokenTypesByCampaign = {};
-    // Round 2: Decode result from round 1 and get some additional info for the types before the final calls
-    const callsRounds2 = [];
-    let i = 0;
     for (const campaign of campaigns) {
-        let typeStruct = {
+        const typeStruct = {
             type: tokenType.unknown,
             calls: [],
             typeInfo: {},
         };
-        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i, campaign);
-        i += 6;
+        const targetToken = campaign.campaignParameters.targetToken;
+        typeStruct.calls = [
+            {
+                allowFailure: true,
+                callData: FactoryInterface.encodeFunctionData("factory"),
+                target: targetToken,
+            },
+            {
+                allowFailure: true,
+                callData: MetamorphoInterface.encodeFunctionData("MORPHO"),
+                target: targetToken,
+            },
+            {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("name"),
+                target: targetToken,
+            },
+            {
+                allowFailure: true,
+                callData: BalancerPoolInterface.encodeFunctionData("getPoolId"),
+                target: targetToken,
+            },
+            {
+                allowFailure: true,
+                callData: EnzymeInterface.encodeFunctionData("getCreator"),
+                target: targetToken,
+            },
+            {
+                allowFailure: true,
+                callData: LayerBankERC20Interface.encodeFunctionData("owner"),
+                target: targetToken,
+            },
+        ];
+        callsRounds1.push(...typeStruct.calls);
         tokenTypesByCampaign[campaign.campaignId] = typeStruct;
-        callsRounds2.push(...typeStruct.calls);
+    }
+    const resultRound1 = await ChainInteractionService(chainId).fetchState(callsRounds1);
+    // Round 2: Decode result from round 1 and get some additional info for the types before the final calls
+    const callsRounds2 = [];
+    let i = 0;
+    for (const campaign of campaigns) {
+        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i, campaign);
+        i += callsForCampaign;
+        callsRounds2.push(...tokenTypesByCampaign[campaign.campaignId].calls);
     }
     const resultRound2 = await ChainInteractionService(chainId).fetchState(callsRounds2);
     // Round 3: Decode result from round 2 and get some additional info for the types before the final calls

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.d.ts

@@ -72,7 +72,9 @@ export declare enum tokenType {
     satlayer = "satlayer",
     veda = "veda",
     superlend_borrowing = "superlend_borrowing",
-    superlend_lending = "superlend_lending"
+    superlend_lending = "superlend_lending",
+    cian = "cian",
+    concrete = "concrete"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.js

@@ -74,6 +74,8 @@ export var tokenType;
     tokenType["veda"] = "veda";
     tokenType["superlend_borrowing"] = "superlend_borrowing";
     tokenType["superlend_lending"] = "superlend_lending";
+    tokenType["cian"] = "cian";
+    tokenType["concrete"] = "concrete";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave" },
@@ -179,4 +181,6 @@ export const tokenTypeToProtocol = {
     [tokenType.veda]: { protocol: "Veda" },
     [tokenType.superlend_borrowing]: { protocol: "Superlend" },
     [tokenType.superlend_lending]: { protocol: "Superlend" },
+    [tokenType.cian]: { protocol: "Cian" },
+    [tokenType.concrete]: { protocol: "Concrete" },
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/ERC4626Processor.d.ts

@@ -0,0 +1,34 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawERC4626;
+    call: string;
+    target: keyof callKeysERC4626;
+    metaData?: any;
+};
+type callKeysERC4626 = mandatoryCallKeys & {
+    asset: string;
+    decimalsAsset: string;
+    name: string;
+    symbolAsset: string;
+    totalAssets: string;
+};
+type dataRawERC4626 = callKeysERC4626 & {};
+type dataTypeERC4626 = dataType & {
+    asset: string;
+    decimalsAsset: string;
+    symbolAsset: string;
+    totalAssets: string;
+};
+export declare class ERC4626Processor extends GenericProcessor<callKeysERC4626, dataRawERC4626, dataTypeERC4626> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawERC4626, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeERC4626>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/ERC4626Processor.js

@@ -0,0 +1,36 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class ERC4626Processor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "asset", call: "asset", target: "tokenAddress" }],
+        round2: [
+            { key: "decimalsAsset", call: "decimals", target: "asset" },
+            { key: "symbolAsset", call: "symbol", target: "asset" },
+        ],
+        round3: [],
+        round4: [
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+            { key: "totalAssets", call: "totalAssets", target: "tokenAddress" },
+        ],
+    };
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceAsset = (await pricer.get({
+            symbol: typeInfo.symbolAsset,
+        })) ?? 0;
+        const decimalsAsset = Number.parseInt(typeInfo.decimalsAsset);
+        const amountAsset = BN2Number(typeInfo.totalAssets, decimalsAsset);
+        const tvl = priceAsset * amountAsset;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/processorMapping.js

@@ -6,6 +6,7 @@ import { BalancerGaugeProcessor } from "./BalancerGaugeProcessor";
 import { BalancerPoolProcessor } from "./BalancerPoolProcessor";
 import { BeefyProcessor } from "./BeefyProcessor";
 import { CompoundProcessor } from "./CompoundProcessor";
+import { ERC4626Processor } from "./ERC4626Processor";
 import { EnzymeProcessor } from "./EnzymeProcessor";
 import { EulerBorrowProcessor } from "./EulerBorrowProcessor";
 import { EulerLendProcessor } from "./EulerLendProcessor";
@@ -109,4 +110,6 @@ export const processorMapping = {
     [tokenType.veda]: NoLinkVaultProcessor,
     [tokenType.superlend_lending]: AaveProcessor,
     [tokenType.superlend_borrowing]: AaveProcessor,
+    [tokenType.cian]: ERC4626Processor,
+    [tokenType.concrete]: ERC4626Processor,
 };

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

@@ -120,6 +120,10 @@ function satisfiesNameConditions(name, type) {
             return lowerCaseName.includes("superlend") && lowerCaseName.includes("debt");
         case tokenType.superlend_lending:
             return lowerCaseName.includes("superlend");
+        case tokenType.cian:
+            return lowerCaseName.includes("cian");
+        case tokenType.concrete:
+            return lowerCaseName.includes("concrete");
         default:
             return false;
     }
@@ -156,7 +160,6 @@ function parseForFactory(calls, targetToken) {
         const factory = decodeReturnValue(calls.factory, "factory");
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromFactoryAddress(factory);
-        console.log("factory: ", factory);
         if (type !== tokenType.unknown)
             return generateResult(type, name, targetToken, { factory });
     }

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

@@ -0,0 +1,5 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+type ReturnType = CampaignDynamicData<Campaign.HYPERDRIVELOGPROCESSOR | Campaign.HYPERDRIVELOGFIXPROCESSOR>[];
+export declare function HyperdriveDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.HYPERDRIVELOGPROCESSOR | Campaign.HYPERDRIVELOGFIXPROCESSOR>[]): Promise<UncachedResult<Partial<ReturnType>>>;
+export {};

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

@@ -0,0 +1,76 @@
+import { BN2Number, HyperdriveTargetInterface, } from "@sdk";
+import { Pricer } from "../../../utils/pricer";
+export async function HyperdriveDynamicData(chainId, campaigns) {
+    const pricer = await Pricer.load();
+    const calls = [];
+    for (const campaign of campaigns) {
+        calls.push({
+            allowFailure: false,
+            callData: HyperdriveTargetInterface.encodeFunctionData("getPoolInfo"),
+            target: campaign.campaignParameters.targetToken,
+        }, {
+            allowFailure: false,
+            callData: HyperdriveTargetInterface.encodeFunctionData("getPoolConfig"),
+            target: campaign.campaignParameters.targetToken,
+        }, {
+            allowFailure: false,
+            callData: HyperdriveTargetInterface.encodeFunctionData("totalSupply", [campaign.campaignParameters.tokenId]),
+            target: campaign.campaignParameters.targetToken,
+        });
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                let i = 0;
+                const dynamicData = [];
+                for (const campaign of campaigns) {
+                    const poolInfo = HyperdriveTargetInterface.decodeFunctionResult("getPoolInfo", result[i++])[0];
+                    const poolConfig = HyperdriveTargetInterface.decodeFunctionResult("getPoolConfig", result[i++])[0];
+                    const totalSupplyVaultToken = BN2Number(HyperdriveTargetInterface.decodeFunctionResult("totalSupply", result[i++])[0]);
+                    const priceRewardToken = (await pricer.get({
+                        address: campaign.rewardToken,
+                        chainId,
+                        symbol: campaign.campaignParameters.symbolRewardToken,
+                    })) ?? 0;
+                    const priceTargetToken = (await pricer.get({
+                        address: campaign.campaignParameters.targetToken,
+                        chainId,
+                        symbol: campaign.campaignParameters.symbolTargetToken,
+                    })) ?? 0;
+                    const priceBaseToken = (await pricer.get({
+                        address: campaign.campaignParameters.baseToken,
+                        chainId,
+                        symbol: campaign.campaignParameters.baseTokenSymbol,
+                    })) ?? 0;
+                    const supply = totalSupplyVaultToken;
+                    dynamicData.push({
+                        ...campaign,
+                        totalSupplyTargetToken: supply,
+                        tvl: 0,
+                        apr: 0,
+                        priceRewardToken: priceRewardToken,
+                    });
+                }
+                return dynamicData;
+            },
+        },
+    };
+}
+// enum AssetIdPrefix {
+//   LP = 0,
+//   Long = 1,
+//   Short = 2,
+//   WithdrawalShare = 3,
+// }
+// function encodeAssetId(prefix: AssetIdPrefix, timestamp: bigint): bigint {
+//   // Check if the timestamp is within the valid range
+//   const maxTimestamp = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+//   if (timestamp > maxTimestamp) {
+//     throw new Error("InvalidTimestamp");
+//   }
+//   // Encode the asset ID
+//   return (BigInt(prefix) << BigInt(248)) | timestamp;
+// }

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

@@ -9,6 +9,7 @@ import { ERC20DynamicData } from "./campaignTypes/ERC20DynamicData";
 import { ERC20_SNAPSHOTDynamicData } from "./campaignTypes/ERC20_SNAPSHOTDynamicData";
 import { EigenLayerDynamicData } from "./campaignTypes/EigenLayerDynamicData";
 import { EulerDynamicData } from "./campaignTypes/EulerDynamicData";
+import { HyperdriveDynamicData } from "./campaignTypes/HyperdriveDynamicData";
 import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData";
 import { MORPHODynamicData } from "./campaignTypes/MORPHODynamicData";
 import { RadiantDynamicData } from "./campaignTypes/RadiantDynamicData";
@@ -71,6 +72,13 @@ export async function campaignsDynamicData(chainId, campaigns, type) {
         case Campaign.VEST: {
             return VestDynamicData(chainId, campaigns);
         }
+        case Campaign.ERC20_FIX_APR: {
+            return ERC20DynamicData(chainId, campaigns);
+        }
+        case Campaign.HYPERDRIVELOGPROCESSOR:
+        case Campaign.HYPERDRIVELOGFIXPROCESSOR: {
+            return HyperdriveDynamicData(chainId, campaigns);
+        }
     }
     return {
         cached: false,

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

@@ -123,6 +123,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                     mainParameter?: string | undefined;
                     campaignId?: string | undefined;
                     opportunityId?: string | undefined;
+                    creatorId?: string | undefined;
                     test?: boolean | undefined;
                     creatorTag?: string | undefined;
                     tokenSymbol?: string | undefined;
@@ -195,6 +196,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                     mainParameter?: string | undefined;
                     campaignId?: string | undefined;
                     opportunityId?: string | undefined;
+                    creatorId?: string | undefined;
                     test?: boolean | undefined;
                     creatorTag?: string | undefined;
                     tokenSymbol?: string | undefined;

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

@@ -122,6 +122,7 @@ export declare const UpdateMetaDataCampaignDto: import("@sinclair/typebox").TObj
 }>;
 export declare const GetCampaignQueryDto: import("@sinclair/typebox").TObject<{
     creatorTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    creatorId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<{
         INVALID: "INVALID";

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

@@ -83,6 +83,7 @@ export const UpdateMetaDataCampaignDto = t.Object({
 });
 export const GetCampaignQueryDto = t.Object({
     creatorTag: t.Optional(t.String({ description: "Filter campaigns created by a user who has a specific tag" })),
+    creatorId: t.Optional(t.String({ description: "Filter campaigns created by a user who is registered as a merkl creator" })),
     chainId: t.Optional(t.Numeric({
         description: "Filter by chain.<br>You can get the list of all supported chains by calling [GET /v4/chains](#tag/chains/GET/v4/chains/)",
     })),

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

@@ -2,7 +2,69 @@ import type { CampaignUnique, CreateCampaignModel, GetCampaignQueryModel, extend
 import { Prisma } from "../../../../database/api/.generated";
 import { type ChainId } from "@sdk";
 export declare abstract class CampaignRepository {
-    #private;
+    static transformQueryToPrismaFilters(query: GetCampaignQueryModel): {
+        where: {
+            computeChainId: number | undefined;
+            endTimestamp: {
+                gte: number;
+            } | undefined;
+            opportunityId: string | undefined;
+            campaignId: string | undefined;
+            Opportunity: {
+                identifier: string | undefined;
+            };
+            startTimestamp: {
+                gte: number;
+            } | undefined;
+            subType: number | undefined;
+            type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER" | "ERC20TRANSFERS" | "ERC20LOGPROCESSOR" | "ERC20REBASELOGPROCESSOR" | "VEST" | "ERC20_FIX_APR" | "HYPERDRIVELOGPROCESSOR" | "HYPERDRIVELOGFIXPROCESSOR" | undefined;
+            RewardToken: {
+                address: string | undefined;
+                symbol: string | undefined;
+                OR: ({
+                    symbol: {
+                        equals: string;
+                        mode: "insensitive";
+                    };
+                    displaySymbol?: undefined;
+                } | {
+                    displaySymbol: {
+                        equals: string;
+                        mode: "insensitive";
+                    };
+                    symbol?: undefined;
+                })[] | undefined;
+                isTest: false | undefined;
+            };
+            Creator: {
+                OR: ({
+                    Creator: {
+                        id: string;
+                    };
+                    tags?: undefined;
+                } | {
+                    tags: {
+                        has: string;
+                    };
+                    Creator?: undefined;
+                })[];
+                Creator?: undefined;
+                tags?: undefined;
+            } | {
+                Creator: {
+                    id: string;
+                };
+                OR?: undefined;
+                tags?: undefined;
+            } | {
+                tags: {
+                    has: string;
+                };
+                OR?: undefined;
+                Creator?: undefined;
+            } | undefined;
+        };
+    };
     static upsert(campaign: CreateCampaignModel): Promise<{
         type: import("../../../../database/api/.generated").$Enums.CampaignType;
         id: string;

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

@@ -8,9 +8,18 @@ import moment from "moment";
 import { OpportunityService } from "../opportunity";
 import { TokenService } from "../token";
 export class CampaignRepository {
-    // ─── Private Methods ─────────────────────────────────────────────────
-    static #transformQueryToPrismaFilters(query) {
-        const { creatorTag, chainId, endTimestamp, opportunityId, mainParameter, campaignId, startTimestamp, subType, type, tokenAddress, tokenSymbol, test, } = query;
+    static transformQueryToPrismaFilters(query) {
+        const { creatorTag, creatorId, chainId, endTimestamp, opportunityId, mainParameter, campaignId, startTimestamp, subType, type, tokenAddress, tokenSymbol, test, } = query;
+        const getTagFilter = () => {
+            if (creatorTag && creatorId)
+                return {
+                    OR: [{ Creator: { id: creatorId } }, { tags: { has: creatorTag } }],
+                };
+            if (creatorId)
+                return { Creator: { id: creatorId } };
+            if (creatorTag)
+                return { tags: { has: creatorTag } };
+        };
         return {
             where: {
                 computeChainId: chainId,
@@ -34,11 +43,7 @@ export class CampaignRepository {
                         : undefined,
                     isTest: !test ? false : undefined,
                 },
-                Creator: creatorTag
-                    ? {
-                        tags: { has: creatorTag },
-                    }
-                    : undefined,
+                Creator: getTagFilter(),
             },
         };
     }
@@ -274,7 +279,7 @@ export class CampaignRepository {
         const { page: _page, items: _items, ...filters } = query;
         const page = _page ? _page : 0;
         const items = _items ? _items : 20;
-        const args = CampaignRepository.#transformQueryToPrismaFilters(query);
+        const args = CampaignRepository.transformQueryToPrismaFilters(query);
         return await apiDbClient.campaign.findMany({
             take: items,
             skip: page * items,
@@ -291,7 +296,7 @@ export class CampaignRepository {
         });
     }
     static async countMany(query) {
-        const args = CampaignRepository.#transformQueryToPrismaFilters(query);
+        const args = CampaignRepository.transformQueryToPrismaFilters(query);
         return await apiDbClient.campaign.count(args);
     }
     static async findManyCampaignId(chainId) {

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

@@ -26,8 +26,9 @@ export declare const ComputedValueController: Elysia<"/value", false, {
                         headers: unknown;
                         response: {
                             200: {
-                                [x: string]: File;
-                                [x: number]: File;
+                                averageBoost: number | null;
+                                totalDistributedInUSD: number | null;
+                                forfeitingBoost: number | null;
                             } | null;
                         };
                     };
@@ -50,8 +51,10 @@ export declare const ComputedValueController: Elysia<"/value", false, {
                         headers: unknown;
                         response: {
                             200: {
-                                [x: string]: never;
-                                [x: number]: never;
+                                reason: string;
+                                id: number;
+                                campaignId: string;
+                                boost: number | null;
                             }[];
                         };
                     };

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

@@ -5,20 +5,22 @@ import { GetCampaignComputedValue, GetUserComputedValues, UpsertCampaignComputed
 import { ComputedValueService } from "./computedValue.service";
 export const ComputedValueController = new Elysia({
     prefix: "/value",
-    detail: { tags: ["Engine"], hide: true },
+    detail: { tags: ["Value"] },
 })
     // ─── Get a Campaign Value ──────────────────────────────────────
     .get("/campaign/:campaignId/:field", async ({ params }) => ComputedValueService.findCampaignValue(params), {
     params: GetCampaignComputedValue,
-    detail: { hide: true },
+    detail: { description: "Gets campaign-level values computed by Merkl Engine (for example average boost)" },
 })
     // ─── Get user Values ──────────────────────────────────────
     .get("/user/:address/:field", async ({ params }) => ComputedValueService.findUserValues(params), {
     params: GetUserComputedValues,
     beforeHandle: ({ params }) => {
-        throwOnInvalidRequiredAddress(params.address);
+        params.address = throwOnInvalidRequiredAddress(params.address);
+    },
+    detail: {
+        description: "Gets campaign-level values computed by Merkl Engine (for example position specific boosts)",
     },
-    detail: { hide: true },
 })
     // ─── Update a Campaign Value ──────────────────────────────────────
     .post("/engine/campaign", async ({ body }) => await ComputedValueService.upsertCampaignComputedValue(body), {
@@ -36,7 +38,7 @@ export const ComputedValueController = new Elysia({
     beforeHandle: ({ headers, body }) => {
         EngineGuard({ headers });
         for (const item of body) {
-            throwOnInvalidRequiredAddress(item.address);
+            item.address = throwOnInvalidRequiredAddress(item.address);
         }
     },
     detail: { hide: true },

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

@@ -1,8 +1,12 @@
 import { t } from "elysia";
 // ─── DTOs ────────────────────────────────────────────────────────────────────
 export const GetCampaignComputedValue = t.Object({
-    campaignId: t.String(),
-    field: t.String(),
+    campaignId: t.String({
+        description: "The campaign Id to get the computed value for. Can be either of the for '0x1234...5678' (solidity id) or '0x1234...5678_<DISTRIBUTION_CHAIN>' or '22222' (Database id).",
+    }),
+    field: t.String({
+        description: "The field you're querying for. Example includes 'averageBoost', 'totalDistributedInUSD', 'forfeitingBoost'. Note that these aren't always available and depend on the campaign type.",
+    }),
 });
 export const UpsertCampaignComputedValue = t.Object({
     campaignId: t.String(),
@@ -10,8 +14,12 @@ export const UpsertCampaignComputedValue = t.Object({
     field: t.String(),
 });
 export const GetUserComputedValues = t.Object({
-    address: t.String(),
-    field: t.String(),
+    address: t.String({
+        description: "The user's address to get the computed values for.",
+    }),
+    field: t.String({
+        description: "The field you're querying for. Example includes 'boost'.",
+    }),
 });
 export const UpsertUserComputedValues = t.Array(t.Object({
     campaignId: t.String(),

package/dist/src/modules/v4/computedValue/computedValue.repository.d.ts

@@ -1,13 +1,16 @@
 import type { GetCampaignComputedValueModel, GetUserComputedValuesModel, UpsertCampaignComputedValueModel, UpsertUserComputedValuesModel } from "./computedValue.model";
 export declare class ComputedValueRepository {
     static findCampaignValue(params: GetCampaignComputedValueModel): Promise<{
-        [x: string]: never;
-        [x: number]: never;
+        averageBoost: number | null;
+        totalDistributedInUSD: number | null;
+        forfeitingBoost: number | null;
     } | null>;
     static upsertCampaignComputedValue(data: UpsertCampaignComputedValueModel): Promise<void>;
-    static findUserValues(params: GetUserComputedValuesModel): Promise<{
-        [x: string]: never;
-        [x: number]: never;
+    static findUserValues(data: GetUserComputedValuesModel): Promise<{
+        reason: string;
+        id: number;
+        campaignId: string;
+        boost: number | null;
     }[]>;
     static upsertUserComputedValues(data: UpsertUserComputedValuesModel): Promise<void>;
 }

package/dist/src/modules/v4/computedValue/computedValue.repository.js

@@ -16,10 +16,14 @@ export class ComputedValueRepository {
             },
         });
     }
-    static async findUserValues(params) {
+    static async findUserValues(data) {
         return await apiDbClient.userComputedValue.findMany({
-            where: { address: params.address },
-            select: { [params.field]: true },
+            where: { address: data.address },
+            select: {
+                campaignId: true,
+                reason: true,
+                [data.field]: true,
+            },
         });
     }
     static async upsertUserComputedValues(data) {