@merkl/api 0.16.21 → 0.16.23

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/curveNPoolProcessor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawCurveN;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/curveNPoolProcessor.js

@@ -1,6 +1,6 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
-import { GenericProcessor } from "./GenericProcessor";
+import { GenericProcessor } from "../GenericProcessor";
 const matchSingleNumber = (input) => {
     const regex = /^\d+$/;
     return regex.test(input);

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/curveProcessor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawCurve;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/curveProcessor.js

@@ -1,7 +1,7 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
 import { tokenType } from "../helpers/tokenType";
-import { GenericProcessor } from "./GenericProcessor";
 export class CurveProcessor extends GenericProcessor {
     rounds = {
         round1: [

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/processorMapping.d.ts

@@ -1,6 +1,6 @@
+import { GenericProcessor } from "../GenericProcessor";
+import type { callKeys, dataRaw, dataType } from "../GenericProcessor";
 import { tokenType } from "../helpers/tokenType";
-import { GenericProcessor } from "./GenericProcessor";
-import type { callKeys, dataRaw, dataType } from "./GenericProcessor";
 export declare const processorMapping: {
     [key in tokenType]: typeof GenericProcessor<callKeys, dataRaw, dataType>;
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/processorMapping.js

@@ -1,3 +1,4 @@
+import { GenericProcessor } from "../GenericProcessor";
 import { tokenType } from "../helpers/tokenType";
 import { AaveProcessor } from "./AaveProcessor";
 import { AnglesLiquidProcessor } from "./AnglesLiquid";
@@ -17,7 +18,6 @@ import { FluidProcessor } from "./FluidProcessor";
 import { FraxProcessor } from "./FraxProcessor";
 import { GammaProcessor } from "./GammaProcessor";
 import { GearboxProcessor } from "./GearboxProcessor";
-import { GenericProcessor } from "./GenericProcessor";
 import { HoldStationProcessor } from "./HoldStationProcessor";
 import { HourglassProcessor } from "./HourglassProcessor";
 import { MaverickBPProcessor } from "./MaverickBPProcessor";

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/stakedCurveProcessor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawStakedCurve;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/stakedCurveProcessor.js

@@ -1,8 +1,8 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { BigNumber } from "ethers";
+import { GenericProcessor } from "../GenericProcessor";
 import { tokenType } from "../helpers/tokenType";
-import { GenericProcessor } from "./GenericProcessor";
 export class StakedCurveProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],

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

@@ -1,5 +1,5 @@
 import { tokenType } from "./helpers/tokenType";
-import { processorMapping } from "./processor/processorMapping";
+import { processorMapping } from "./implementations/processorMapping";
 export async function getTokenPricesInfo(index, type, typeInfo, calls, campaign, pricer) {
     const ProcessorClass = processorMapping[type];
     try {

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

@@ -4,7 +4,7 @@ import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } fro
 import { getTypeFromAddressChain } from "./helpers/hardcoded";
 import { getTypeFromOwnerAddress } from "./helpers/ownerFinder";
 import { tokenType } from "./helpers/tokenType";
-import { processorMapping } from "./processor/processorMapping";
+import { processorMapping } from "./implementations/processorMapping";
 function satisfiesNameConditions(name, type) {
     const lowerCaseName = name.toLowerCase();
     switch (type) {

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

@@ -1,4 +1,4 @@
-import { processorMapping } from "./processor/processorMapping";
+import { processorMapping } from "./implementations/processorMapping";
 export function getTokenTypeRound2(index, type, typeInfo, calls, campaign) {
     try {
         const returnValueOfCalls = calls.map(call => call.returnData);

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound3.d.ts

@@ -1,2 +1,3 @@
+import type { ResultDto } from "@sdk";
 import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
 export declare function getTokenTypeRound3(index: number, type: tokenType, typeInfo: any, calls: ResultDto[]): tokenTypeStruct;

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

@@ -1,4 +1,4 @@
-import { processorMapping } from "./processor/processorMapping";
+import { processorMapping } from "./implementations/processorMapping";
 export function getTokenTypeRound3(index, type, typeInfo, calls) {
     try {
         const ProcessorClass = processorMapping[type];

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

@@ -1,4 +1,4 @@
-import { processorMapping } from "./processor/processorMapping";
+import { processorMapping } from "./implementations/processorMapping";
 export function getTokenTypeRound4(index, type, typeInfo, calls, campaign) {
     try {
         const ProcessorClass = processorMapping[type];

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

@@ -12,22 +12,30 @@ const CALLS_LENGTH = 2;
  *      it's only an estimate
  */
 async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID, priceCurrency0, priceCurrency1, decimalsCurrency0, decimalsCurrency1) {
-    const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
-    const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
-        where: {
-            id: `UniswapV4_${chainId}_${poolID}`,
-            blockNumber: {
-                lte: currentBlock,
+    let stateSave;
+    let blockNumber;
+    let states = {};
+    try {
+        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
+        const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
+            where: {
+                id: `UniswapV4_${chainId}_${poolID}`,
+                blockNumber: {
+                    lte: currentBlock,
+                },
             },
-        },
-        orderBy: {
-            blockNumber: "desc",
-        },
-    });
-    const stateSave = mostRecentStateSave.state;
-    const blockNumber = mostRecentStateSave?.blockNumber;
-    const states = stateSave.states;
-    // const globalState = stateSave.globalState as { tick: number; liquidity: string };
+            orderBy: {
+                blockNumber: "desc",
+            },
+        });
+        stateSave = mostRecentStateSave.state;
+        blockNumber = mostRecentStateSave?.blockNumber;
+        states = stateSave.states;
+        // const globalState = stateSave.globalState as { tick: number; liquidity: string };
+    }
+    catch (e) {
+        log.warn(`merklDynamic data - failed to read a recent state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
+    }
     const { fileName, bucketName } = states;
     // Bucket service
     let tvl = 0;

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

@@ -3136,6 +3136,28 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
+        } & {
+            engine: {
+                computedUntil: {
+                    ":campaignId": {
+                        put: {
+                            body: {
+                                computedUntil: number;
+                            };
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: void;
+                            };
+                        };
+                    };
+                };
+            };
         } & {
             engine: {
                 overlaps: {

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

@@ -44,6 +44,28 @@ export declare const StatusController: Elysia<"/campaign-status", false, {
                 };
             };
         };
+    } & {
+        engine: {
+            computedUntil: {
+                ":campaignId": {
+                    put: {
+                        body: {
+                            computedUntil: number;
+                        };
+                        params: {
+                            campaignId: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
+                };
+            };
+        };
     } & {
         engine: {
             overlaps: {

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

@@ -1,7 +1,7 @@
 import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.guard";
 import { throwOnUnsupportedChainId } from "../../../utils/throw";
 import Elysia from "elysia";
-import { CampaignUniqueDto, DelayDto, QueryCampaignStatusDto, UpdateCampaignStatusDto } from "./status.model";
+import { CampaignUniqueDto, ComputedUntilDto, DelayDto, QueryCampaignStatusDto, UpdateCampaignStatusDto, } from "./status.model";
 import { StatusService } from "./status.service";
 export const StatusController = new Elysia({ prefix: "/campaign-status", detail: { tags: ["Status"], hide: true } })
     // ─── Update a Campaign Status ──────────────────────────────────────
@@ -12,6 +12,15 @@ export const StatusController = new Elysia({ prefix: "/campaign-status", detail:
     beforeHandle: EngineGuard,
     headers: AuthorizationHeadersDto,
     body: UpdateCampaignStatusDto,
+})
+    // ─── Updates only the computed until field ───────────────────────────
+    .put("/engine/computedUntil/:campaignId", async ({ params, body }) => {
+    const [distributionChain, campaignId] = params.campaignId.split("-");
+    return await StatusService.updateComputedUntil({ distributionChain: +distributionChain, campaignId }, body.computedUntil);
+}, {
+    beforeHandle: EngineGuard,
+    headers: AuthorizationHeadersDto,
+    body: ComputedUntilDto,
 })
     // ─── Is Safe For Overlaps ───────────────────────────────────────────
     .get("/engine/overlaps", async ({ query }) => await StatusService.isSafeForOverlaps(query), {

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

@@ -35,6 +35,9 @@ export declare const UpdateCampaignStatusDto: import("@sinclair/typebox").TUnion
     error: import("@sinclair/typebox").TString;
     details: import("@sinclair/typebox").TString;
 }>]>;
+export declare const ComputedUntilDto: import("@sinclair/typebox").TObject<{
+    computedUntil: import("@sinclair/typebox").TNumber;
+}>;
 export declare const QueryCampaignStatusDto: import("@sinclair/typebox").TObject<{
     computeChainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TArray<import("@sinclair/typebox").TEnum<{

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

@@ -26,6 +26,7 @@ export const UpdateCampaignStatusDto = t.Union([
     t.Object({ value: t.Literal(RunStatus.SKIPPED), error: t.String(), details: t.String() }),
     t.Object({ value: t.Literal(RunStatus.FAILED), error: t.String(), details: t.String() }),
 ]);
+export const ComputedUntilDto = t.Object({ computedUntil: t.Numeric() });
 export const QueryCampaignStatusDto = t.Object({
     computeChainId: t.Optional(t.Numeric()),
     status: t.Optional(t.Union([t.Array(t.Enum(RunStatus)), t.Enum(RunStatus)])),

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

@@ -59,21 +59,15 @@ export declare class StatusRepository {
         computedUntil: bigint;
         processingStarted: bigint;
     }>;
-    static updateProcessing(campaignUnique: CampaignUnique): Promise<[{
+    static updateProcessing(campaignUnique: CampaignUnique): Promise<void>;
+    static updateComputedUntil(campaignUnique: CampaignUnique, computedUntil: number): Promise<{
         error: string;
         details: Prisma.JsonValue;
         status: import("../../../../database/api/.generated").$Enums.RunStatus;
         campaignId: string;
         computedUntil: bigint;
         processingStarted: bigint;
-    }, {
-        error: string;
-        details: Prisma.JsonValue;
-        status: import("../../../../database/api/.generated").$Enums.RunStatus;
-        campaignId: string;
-        computedUntil: bigint;
-        processingStarted: bigint;
-    }]>;
+    }>;
     static findManyDelay(query: DelayModel): Promise<{
         startTimestamp: bigint;
         endTimestamp: bigint;

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

@@ -73,8 +73,8 @@ export class StatusRepository {
     static async updateProcessing(campaignUnique) {
         const campaignId = CampaignService.hashId(campaignUnique);
         const now = moment().unix();
-        return await apiDbClient.$transaction([
-            apiDbClient.campaignStatus.findUniqueOrThrow({
+        return await apiDbClient.$transaction(async (_prisma) => {
+            await apiDbClient.campaignStatus.findUniqueOrThrow({
                 where: {
                     campaignId,
                     OR: [
@@ -90,8 +90,8 @@ export class StatusRepository {
                         },
                     ],
                 },
-            }),
-            apiDbClient.campaignStatus.update({
+            });
+            await apiDbClient.campaignStatus.update({
                 where: {
                     campaignId,
                 },
@@ -101,8 +101,18 @@ export class StatusRepository {
                     error: "",
                     details: "{}",
                 },
-            }),
-        ]);
+            });
+        });
+    }
+    static async updateComputedUntil(campaignUnique, computedUntil) {
+        return await apiDbClient.campaignStatus.update({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+            data: {
+                computedUntil,
+            },
+        });
     }
     static async findManyDelay(query) {
         return await apiDbClient.campaign.findMany({

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

@@ -34,6 +34,7 @@ export declare class StatusService {
         processingStarted: bigint;
     } | null>;
     static update(campaignUnique: CampaignUnique, status: UpdateStatusModel): Promise<void>;
+    static updateComputedUntil(campaignUnique: CampaignUnique, computedUntil: number): Promise<void>;
     static isSafeForOverlaps(campaignUnique: CampaignUnique): Promise<boolean>;
     static findUpdatesAndDelays(): Promise<Record<number, {
         live: string;

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

@@ -45,6 +45,19 @@ export class StatusService {
                 return;
         }
     }
+    static async updateComputedUntil(campaignUnique, computedUntil) {
+        // Check if the status exists already, otherwise create it
+        const campaignStatus = await StatusRepository.findUnique(campaignUnique);
+        if (!campaignStatus) {
+            let campaign = await CampaignService.findUnique(campaignUnique);
+            if (!campaign) {
+                await CampaignService.fill([campaignUnique]);
+                campaign = await CampaignService.findUniqueOrThrow(campaignUnique);
+            }
+            await StatusRepository.create(campaignUnique, campaign.startTimestamp);
+        }
+        await StatusRepository.updateComputedUntil(campaignUnique, computedUntil);
+    }
     static async isSafeForOverlaps(campaignUnique) {
         const status = await StatusRepository.findUnique(campaignUnique);
         if (!status) {

package/dist/src/utils/generateIcons.js

@@ -44,6 +44,13 @@ export function generateIcons(type, typeInfo, campaign, symbols = [""]) {
                 case tokenType.toros:
                 case tokenType.enzyme:
                     return [typeInfo.symbolUnderlyingToken];
+                case tokenType.pendleYT: {
+                    let symbol = campaign.campaignParameters.symbolTargetToken;
+                    symbol = symbol.split("-").slice(0, 2).join("-");
+                    return [symbol];
+                }
+                case tokenType.pendle:
+                    return [typeInfo.symbolUnderlyingToken];
                 default:
                     return [campaign.campaignParameters.symbolTargetToken];
             }