@merkl/api 0.16.21 → 0.16.22

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

@@ -2670,6 +2670,21 @@ declare const eden: {
                     200: void;
                 }>>;
             }) & {
+                computedUntil: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    put: (body: {
+                        computedUntil: number;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {};
                 overlaps: {
                     get: (options: {
                         headers: {
@@ -5847,6 +5862,21 @@ declare const eden: {
                     200: void;
                 }>>;
             }) & {
+                computedUntil: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    put: (body: {
+                        computedUntil: number;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {};
                 overlaps: {
                     get: (options: {
                         headers: {
@@ -10318,6 +10348,28 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
+        } & {
+            engine: {
+                computedUntil: {
+                    ":campaignId": {
+                        put: {
+                            body: {
+                                computedUntil: number;
+                            };
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: void;
+                            };
+                        };
+                    };
+                };
+            };
         } & {
             engine: {
                 overlaps: {
@@ -14567,6 +14619,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     200: void;
                 }>>;
             }) & {
+                computedUntil: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    put: (body: {
+                        computedUntil: number;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {};
                 overlaps: {
                     get: (options: {
                         headers: {
@@ -17744,6 +17811,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     200: void;
                 }>>;
             }) & {
+                computedUntil: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    put: (body: {
+                        computedUntil: number;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {};
                 overlaps: {
                     get: (options: {
                         headers: {

package/dist/src/index.d.ts

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

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

@@ -74,6 +74,14 @@ export declare class StatusRepository {
         computedUntil: bigint;
         processingStarted: bigint;
     }]>;
+    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;
+    }>;
     static findManyDelay(query: DelayModel): Promise<{
         startTimestamp: bigint;
         endTimestamp: bigint;

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

@@ -104,6 +104,16 @@ export class StatusRepository {
             }),
         ]);
     }
+    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({
             where: {

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];
             }