@merkl/api 0.20.110 → 0.20.112

package/dist/src/eden/index.d.ts

@@ -3162,6 +3162,17 @@ declare const eden: {
                     })[];
                 }>>;
             };
+            terms: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        chainId: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            };
             tags: {
                 patch: (body: {
                     tags: string[];
@@ -8887,6 +8898,26 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
+    } & {
+        users: {
+            ":address": {
+                terms: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            address: string;
+                        };
+                        query: {
+                            chainId: number;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: boolean;
+                        };
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -14289,6 +14320,17 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     })[];
                 }>>;
             };
+            terms: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        chainId: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            };
             tags: {
                 patch: (body: {
                     tags: string[];

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

@@ -12,7 +12,7 @@ export class Erc20TVLBuilder {
             const builder = erc20SubTypeTVLBuilderFactory(subType);
             const campaignsOfSubType = campaigns.filter((_campaign, index) => subTypes[index] === subType);
             if (!!builder) {
-                log.info(`building TVLs for subtype ${subType}`);
+                log.local(`building TVLs for subtype ${subType}`);
                 const subTypeTVLs = await builder.build(computeChainId, campaignsOfSubType);
                 // Impact blacklist or whitelist
                 const calls = [];
@@ -51,6 +51,7 @@ export class Erc20TVLBuilder {
                 const result = await ChainInteractionService(computeChainId).fetchState(calls);
                 let index = 0;
                 for (const [i, { campaign }] of subTypeTVLs.entries()) {
+                    log.local(`building TVLs for subtype ${subType} using deprecated code`);
                     const { campaignParameters } = campaign;
                     const { whitelist, blacklist } = campaignParameters;
                     if (whitelist?.length > 0) {

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

@@ -14,6 +14,10 @@ const map = {
     [Campaign.AMBIENTPROCESSOR]: new AmbiantTVLBuilder(),
     [Campaign.UNISWAP_V4]: new UniswapV4TVLBuilder(),
     [Campaign.ERC20]: new Erc20TVLBuilder(),
+    [Campaign.ERC20LOGPROCESSOR]: new Erc20TVLBuilder(),
+    [Campaign.ERC20REBASEFIXAPR]: new Erc20TVLBuilder(),
+    [Campaign.ERC20_FIX_APR]: new Erc20TVLBuilder(),
+    [Campaign.EULER]: new Erc20TVLBuilder(),
 };
 export const campaignTVLBuilderFactory = (campaignType) => {
     if (!map[campaignType]) {

package/dist/src/index.d.ts

@@ -3932,6 +3932,26 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        users: {
+            ":address": {
+                terms: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            address: string;
+                        };
+                        query: {
+                            chainId: number;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: boolean;
+                        };
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {

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

@@ -10,7 +10,7 @@ import { TvlService } from "@/modules/v4/tvl/tvl.service";
 import bigintToString from "@/utils/bigintToString";
 import { log } from "@/utils/logger";
 import { AprType } from "@db/api";
-import { Campaign as CampaignEnum, DAY, NETWORK_LABELS, } from "@sdk";
+import { Campaign as CampaignEnum, DAY, NETWORK_LABELS, bigIntToNumber, } from "@sdk";
 import moment from "moment";
 import { AprService } from "../apr";
 import { CampaignService } from "../campaign";
@@ -96,6 +96,7 @@ export class DynamicDataService {
                         let campaignDailyValue = await TokenService.getValueByTokenId(TokenService.hashId({ address: rewardTokenAddress, chainId: record.campaign.chainId }), dailyAmount);
                         // Fixed APR campaigns
                         if (hasFixedAprConfig(campaignParameters)) {
+                            log.local(`[${NETWORK_LABELS[chainId]}][${CampaignEnum[type]}] calculating fixed APR for ${record.campaign.campaignId}`);
                             const { targetTokenPricing, rewardTokenPricing, apr: fixedApr } = campaignParameters;
                             const targetApr = Number(fixedApr);
                             if (targetTokenPricing && rewardTokenPricing) {
@@ -106,8 +107,11 @@ export class DynamicDataService {
                             if (targetTokenPricing && !rewardTokenPricing) {
                                 // Case 2: Fixed # amount of reward per $ of liquidity
                                 // Return 0 if reward token price is invalid
-                                campaignDailyValue = !rewardToken.price ? 0 : targetApr * rewardToken.price * tvl.total;
-                                dailyAmount = BigInt((campaignDailyValue / (rewardToken.price ?? 1)) * 10 ** rewardToken.decimals);
+                                // targetApr represents a yearly # amount of reward per $ of liquidity
+                                dailyAmount =
+                                    (BigInt(Math.floor((targetApr * tvl.total * 10 ** 6) / 365)) * 10n ** BigInt(rewardToken.decimals)) /
+                                        10n ** 6n;
+                                campaignDailyValue = bigIntToNumber(dailyAmount, rewardToken.decimals) * (rewardToken.price ?? 1);
                             }
                         }
                         dailyRewards.total += campaignDailyValue;

package/dist/src/modules/v4/router.d.ts

@@ -3802,6 +3802,26 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        users: {
+            ":address": {
+                terms: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            address: string;
+                        };
+                        query: {
+                            chainId: number;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: boolean;
+                        };
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {

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

@@ -379,6 +379,26 @@ export declare const UserController: Elysia<"/users", false, {
             };
         };
     };
+} & {
+    users: {
+        ":address": {
+            terms: {
+                get: {
+                    body: unknown;
+                    params: {
+                        address: string;
+                    };
+                    query: {
+                        chainId: number;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: boolean;
+                    };
+                };
+            };
+        };
+    };
 } & {
     users: {
         ":address": {

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

@@ -3,7 +3,7 @@ import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/util
 import { Elysia, t } from "elysia";
 import { CreatorService } from "../creator";
 import { RewardService } from "../reward";
-import { GetManyUserQuery, OptionalChainIdDto, UpdateUserTagsDto, UserDto, UserRewardRouteDto, UserRewardsResourceDto, UserUniqueDto, } from "./user.model";
+import { CheckTerms, GetManyUserQuery, OptionalChainIdDto, UpdateUserTagsDto, UserDto, UserRewardRouteDto, UserRewardsResourceDto, UserUniqueDto, } from "./user.model";
 import { UserService } from "./user.service";
 // ─── Users Controller ────────────────────────────────────────────────────────
 export const UserController = new Elysia({ prefix: "/users", detail: { tags: ["Users"] } })
@@ -78,6 +78,13 @@ export const UserController = new Elysia({ prefix: "/users", detail: { tags: ["U
     headers: AuthorizationHeadersDto,
     beforeHandle: BackOfficeGuard,
     detail: { hide: true },
+})
+    // ─── Check if user has signed terms ─────────────────────────────────
+    .get("/:address/terms", async ({ query, params }) => await UserService.checkTerms(params?.address, query?.chainId), {
+    query: CheckTerms,
+    detail: {
+        description: "Check if a user address has signed Merkl's terms.",
+    },
 })
     // ─── Update User's Tags ──────────────────────────────────────────────
     .patch("/:address/tags", async ({ params, body }) => UserService.updateTags(params.address, body.tags), {

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

@@ -63,6 +63,9 @@ export declare const GetManyUserQuery: import("@sinclair/typebox").TObject<{
     page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;
+export declare const CheckTerms: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+}>;
 export declare const UpdateUserTagsDto: import("@sinclair/typebox").TObject<{
     tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
 }>;

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

@@ -64,6 +64,9 @@ export const GetManyUserQuery = t.Object({
     page: t.Optional(t.Number()),
     items: t.Optional(t.Number()),
 });
+export const CheckTerms = t.Object({
+    chainId: t.Numeric(),
+});
 export const UpdateUserTagsDto = t.Object({
     tags: t.Array(t.String()),
 });

package/dist/src/modules/v4/user/user.service.d.ts

@@ -26,6 +26,7 @@ export declare abstract class UserService {
         address: string;
         creatorId: string | null;
     }>;
+    static checkTerms(userAddress: string, chainId: number): Promise<boolean>;
     static syncTags(): Promise<void>;
     static syncOpportunityTags(): Promise<void>;
 }

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

@@ -1,5 +1,6 @@
 import { log } from "@/utils/logger";
 import { engineDbClient } from "@db";
+import { ChainInteractionService, DistributionCreatorInterface, registry } from "@sdk";
 import { OpportunityService } from "../opportunity";
 import { UserRepository } from "./user.repository";
 // ─── Users Services ──────────────────────────────────────────────────────────
@@ -25,6 +26,37 @@ export class UserService {
         }
         return await UserRepository.updateTags(user, tags);
     }
+    static async checkTerms(userAddress, chainId) {
+        const distributorAddress = registry(chainId)?.Merkl?.DistributionCreator;
+        if (!distributorAddress)
+            throw new Error(`Distributor address not found for chainId ${chainId}`);
+        const calls = [
+            {
+                callData: DistributionCreatorInterface.encodeFunctionData("userSignatureWhitelist", [userAddress]),
+                target: distributorAddress,
+                allowFailure: false,
+            },
+            {
+                callData: DistributionCreatorInterface.encodeFunctionData("userSignatures", [userAddress]),
+                target: distributorAddress,
+                allowFailure: false,
+            },
+            {
+                callData: DistributionCreatorInterface.encodeFunctionData("messageHash"),
+                target: distributorAddress,
+                allowFailure: false,
+            },
+        ];
+        const decoders = (r) => [
+            DistributionCreatorInterface.decodeFunctionResult("userSignatureWhitelist", r[0].returnData)[0].toString(),
+            DistributionCreatorInterface.decodeFunctionResult("userSignatures", r[1].returnData)[0].toString(),
+            DistributionCreatorInterface.decodeFunctionResult("messageHash", r[2].returnData)[0].toString(),
+        ];
+        const result = await ChainInteractionService(chainId).fetchAndDecodeMultiple(calls, decoders);
+        const [signatureWhitelist, userSignature, messageHash] = result;
+        const hasNotSigned = signatureWhitelist === "0" && userSignature !== messageHash;
+        return !hasNotSigned;
+    }
     static async syncTags() {
         // 1 - engine -> api db
         const creatorTags = await engineDbClient.campaignCreators.findMany();