@merkl/api 0.16.39 → 0.16.41

package/dist/src/jobs/etl/update-dynamic-data.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/jobs/etl/update-dynamic-data.js

@@ -0,0 +1,71 @@
+import { campaignsDynamicData } from "../../libs/campaigns/campaignsDynamicData";
+import { AprService } from "../../modules/v4/apr";
+import { CampaignService } from "../../modules/v4/campaign";
+import { OpportunityService } from "../../modules/v4/opportunity";
+import { OpportunityRepository } from "../../modules/v4/opportunity/opportunity.repository";
+import { RewardService } from "../../modules/v4/reward";
+import { TvlService } from "../../modules/v4/tvl";
+import { executeSimple } from "../../utils/execute";
+import { Campaign } from "@sdk";
+const chainId = Number(process.env.CHAIN_ID);
+if (!chainId)
+    throw new Error("Environment variable CHAIN_ID is required.");
+const campaignType = process.env.CAMPAIGN_TYPE;
+if (!campaignType)
+    throw new Error("Environment variable CAMPAIGN_TYPE is required.");
+async function updateDynamicData() {
+    const liveCampaigns = (await CampaignService.getLiveCampaigns({ computeChainId: chainId, type: campaignType })).map(c => {
+        return {
+            amount: c.amount,
+            campaignId: c.campaignId,
+            mainParameter: c.Opportunity.identifier,
+            campaignParameters: c.params,
+            campaignSubType: c.subType,
+            campaignType,
+            chainId: c.distributionChainId,
+            computeChainId: c.computeChainId,
+            creator: c.creatorAddress,
+            endTimestamp: c.endTimestamp,
+            rewardToken: c.rewardTokenId,
+            startTimestamp: c.startTimestamp,
+        };
+    });
+    const dynamicData = await executeSimple(chainId, campaignsDynamicData(chainId, liveCampaigns, campaignType));
+    const oppMap = {};
+    for (const data of dynamicData) {
+        if (!!data) {
+            // Main Parameter OVERRIDING
+            if (data.campaignType === Campaign.SILO && data.campaignParameters.whitelist?.length === 1)
+                data.mainParameter = `${data.mainParameter}-${data.campaignParameters.whitelist[0]}`;
+            if (!oppMap[`${data.campaignType}_${data.mainParameter}`])
+                oppMap[`${data.campaignType}_${data.mainParameter}`] = {};
+            oppMap[`${data.campaignType}_${data.mainParameter}`][data.campaignId] = data;
+        }
+    }
+    for (const entry of Object.entries(oppMap)) {
+        const [type, mainParameter] = entry[0].split("_");
+        try {
+            const apr = AprService.extractFromDynamicData(+type, Object.values(entry[1]));
+            const tvl = TvlService.extractFromDynamicData(+type, Object.values(entry[1]));
+            const dailyRewards = await RewardService.extractDailyRewardsRecordFromDynamicData(+type, Object.values(entry[1]));
+            const opportunityId = OpportunityService.hashId({
+                chainId,
+                identifier: mainParameter,
+                type: type,
+            });
+            await OpportunityRepository.updateRecords(opportunityId, apr, tvl, dailyRewards);
+        }
+        catch (err) {
+            console.log(mainParameter);
+            console.error(err);
+        }
+    }
+}
+try {
+    await updateDynamicData();
+    process.exit(0);
+}
+catch (err) {
+    console.error(err);
+    process.exit(1);
+}

package/dist/src/libs/campaigns/campaignsDynamicData.d.ts

@@ -1,3 +1,3 @@
 import { Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
 import type { UncachedResult } from "../../utils/execute";
-export declare function campaignsDynamicData<T extends Campaign>(chainId: MerklChainId, campaigns: CampaignParameters<T>[], type: T): Promise<UncachedResult<Partial<CampaignDynamicData<T>[]>>>;
+export declare function campaignsDynamicData<T extends Campaign>(chainId: MerklChainId, campaigns: CampaignParameters<T>[], type: T | string): Promise<UncachedResult<Partial<CampaignDynamicData<T>[]>>>;

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

@@ -26,67 +26,89 @@ export async function campaignsDynamicData(chainId, campaigns, type) {
     }
     catch (_err) { }
     switch (type) {
+        case "ERC20":
         case Campaign.ERC20: {
             return ERC20DynamicData(chainId, campaigns);
         }
+        case "ERC20LOGPROCESSOR":
         case Campaign.ERC20LOGPROCESSOR: {
             return ERC20DynamicData(chainId, campaigns);
         }
+        case "ERC20REBASELOGPROCESSOR":
         case Campaign.ERC20REBASELOGPROCESSOR: {
             return ERC20DynamicData(chainId, campaigns);
         }
+        case "CLAMM":
         case Campaign.CLAMM: {
             return CLAMMDynamicData(chainId, campaigns);
         }
+        case "ERC20_SNAPSHOT":
         case Campaign.ERC20_SNAPSHOT: {
             return ERC20_SNAPSHOTDynamicData(chainId, campaigns);
         }
+        case "JSON_AIRDROP":
         case Campaign.JSON_AIRDROP: {
             return JSON_AIRDROPDynamicData(chainId, campaigns);
         }
+        case "SILO":
         case Campaign.SILO: {
             return SILODynamicData(chainId, campaigns);
         }
+        case "RADIANT":
         case Campaign.RADIANT: {
             return RadiantDynamicData(chainId, campaigns);
         }
+        case "MORPHO":
         case Campaign.MORPHO: {
             return MORPHODynamicData(chainId, campaigns);
         }
+        case "EULER":
         case Campaign.EULER: {
             return ERC20DynamicData(chainId, campaigns);
         }
+        case "DOLOMITE":
         case Campaign.DOLOMITE: {
             return DolomiteDynamicData(chainId, campaigns);
         }
+        case "BADGER":
         case Campaign.BADGER: {
             return BadgerDynamicData(chainId, campaigns);
         }
+        case "AJNA":
         case Campaign.AJNA: {
             return AjnaDynamicData(chainId, campaigns);
         }
+        case "COMPOUND":
         case Campaign.COMPOUND: {
             return CompoundDynamicData(chainId, campaigns);
         }
+        case "EIGENLAYER":
         case Campaign.EIGENLAYER: {
             return EigenLayerDynamicData(chainId, campaigns);
         }
+        case "VEST":
         case Campaign.VEST: {
             return VestDynamicData(chainId, campaigns);
         }
+        case "ERC20_FIX_APR":
         case Campaign.ERC20_FIX_APR: {
             return ERC20DynamicData(chainId, campaigns);
         }
+        case "HYPERDRIVELOGPROCESSOR":
+        case "HYPERDRIVELOGFIXPROCESSOR":
         case Campaign.HYPERDRIVELOGPROCESSOR:
         case Campaign.HYPERDRIVELOGFIXPROCESSOR: {
             return HyperdriveDynamicData(chainId, campaigns);
         }
+        case "AMBIENTPROCESSOR":
         case Campaign.AMBIENTPROCESSOR: {
             return AmbientDynamicData(chainId, campaigns);
         }
+        case "UNISWAP_V4":
         case Campaign.UNISWAP_V4: {
             return UniswapV4DynamicData(chainId, campaigns);
         }
+        case "ENCOMPASSING":
         case Campaign.ENCOMPASSING: {
             return EncompassingDynamicData(chainId, campaigns);
         }

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

@@ -0,0 +1,3 @@
+export declare class AirflowService {
+    static triggerDAGRun(dagId: string, conf: object): Promise<void>;
+}

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

@@ -0,0 +1,20 @@
+import { log } from "../../../utils/logger";
+import { withRetry } from "@sdk";
+import { GoogleAuth } from "google-auth-library";
+export class AirflowService {
+    static async triggerDAGRun(dagId, conf) {
+        const auth = new GoogleAuth({
+            scopes: "https://www.googleapis.com/auth/cloud-platform",
+        });
+        const client = await auth.getClient();
+        const reqParams = {
+            method: "POST",
+            url: `${process.env.AIRFLOW_URL}/api/v1/dags/${dagId}/dagRuns`,
+            data: {
+                conf,
+            },
+        };
+        await withRetry(async () => await client.request(reqParams), [], 2, 10_000);
+        log.info(`✅ triggered DAG ${dagId}`);
+    }
+}

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

@@ -66,6 +66,86 @@ export declare abstract class CampaignRepository {
             } | undefined;
         };
     };
+    /**
+     * Retrieves all past campaigns from the database.
+     * A campaign is considered past if the current timestamp is greater than the campaign's end timestamp.
+     *
+     * @returns A promise that resolves to an array of past campaigns.
+     */
+    static getPastCampaigns(chainId?: number): Promise<{
+        type: string;
+        id: string;
+        params: Prisma.JsonValue;
+        subType: number | null;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        computeChainId: number;
+        distributionChainId: number;
+        campaignId: string;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        creatorAddress: string;
+    }[]>;
+    /**
+     * Retrieves all live campaigns from the database.
+     * A campaign is considered live if the current timestamp is between the campaign's start and end timestamps.
+     *
+     * @returns A promise that resolves to an array of live campaigns.
+     */
+    static getLiveCampaigns(query?: {
+        computeChainId?: number;
+        type?: string;
+    }): Promise<({
+        Opportunity: {
+            name: string;
+            type: string;
+            id: string;
+            status: import("../../../../database/api/.generated").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            chainId: number;
+            action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        };
+    } & {
+        type: string;
+        id: string;
+        params: Prisma.JsonValue;
+        subType: number | null;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        computeChainId: number;
+        distributionChainId: number;
+        campaignId: string;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        creatorAddress: string;
+    })[]>;
+    /**
+     * Upserts a campaign in the database. If the campaign already exists, it updates the existing record;
+     * otherwise, it creates a new one.
+     *
+     * @param {CreateCampaignModel} campaign - The campaign data to be upserted.
+     * @returns The upserted campaign record.
+     *
+     * @throws {Error} If unable to fetch data for the reward token.
+     *
+     * @remarks
+     * This method performs the following steps:
+     * 1. Determines the campaign type from the provided campaign data.
+     * 2. Fetches or creates the reward token associated with the campaign.
+     * 3. Parses the campaign parameters.
+     * 4. Computes the opportunity ID based on the campaign data.
+     * 5. Constructs the data object for the campaign to be upserted.
+     * 6. Upserts the campaign in the database using the constructed data object.
+     * 7. Logs an error if the upsert operation fails.
+     */
     static upsert(campaign: CreateCampaignModel): Promise<{
         type: string;
         id: string;
@@ -86,7 +166,7 @@ export declare abstract class CampaignRepository {
         fail: number;
     }>;
     /**
-     * Fetches the campaign static data for a v3 campaign in database
+     * Fetches the campaign data for a v3 campaign in database
      * @param chainId
      * @param timestamp from which campaigns endTimestamp are filtered
      * @returns

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

@@ -49,6 +49,62 @@ export class CampaignRepository {
         };
     }
     // ─── Public Methods ──────────────────────────────────────────────────
+    /**
+     * Retrieves all past campaigns from the database.
+     * A campaign is considered past if the current timestamp is greater than the campaign's end timestamp.
+     *
+     * @returns A promise that resolves to an array of past campaigns.
+     */
+    static async getPastCampaigns(chainId) {
+        const now = moment().unix();
+        return await apiDbClient.campaign.findMany({
+            where: {
+                computeChainId: chainId,
+                endTimestamp: {
+                    lt: now,
+                },
+            },
+        });
+    }
+    /**
+     * Retrieves all live campaigns from the database.
+     * A campaign is considered live if the current timestamp is between the campaign's start and end timestamps.
+     *
+     * @returns A promise that resolves to an array of live campaigns.
+     */
+    static async getLiveCampaigns(query) {
+        const now = moment().unix();
+        const where = {
+            ...query,
+            endTimestamp: { gte: now },
+            startTimestamp: { lte: now },
+        };
+        return await apiDbClient.campaign.findMany({
+            where,
+            include: {
+                Opportunity: true,
+            },
+        });
+    }
+    /**
+     * Upserts a campaign in the database. If the campaign already exists, it updates the existing record;
+     * otherwise, it creates a new one.
+     *
+     * @param {CreateCampaignModel} campaign - The campaign data to be upserted.
+     * @returns The upserted campaign record.
+     *
+     * @throws {Error} If unable to fetch data for the reward token.
+     *
+     * @remarks
+     * This method performs the following steps:
+     * 1. Determines the campaign type from the provided campaign data.
+     * 2. Fetches or creates the reward token associated with the campaign.
+     * 3. Parses the campaign parameters.
+     * 4. Computes the opportunity ID based on the campaign data.
+     * 5. Constructs the data object for the campaign to be upserted.
+     * 6. Upserts the campaign in the database using the constructed data object.
+     * 7. Logs an error if the upsert operation fails.
+     */
     static async upsert(campaign) {
         const campaignType = CampaignService.getTypeFromV3(campaign.type);
         try {
@@ -174,7 +230,7 @@ export class CampaignRepository {
         return { success: successCampaigns.length, fail: failedCampaigns.length };
     }
     /**
-     * Fetches the campaign static data for a v3 campaign in database
+     * Fetches the campaign data for a v3 campaign in database
      * @param chainId
      * @param timestamp from which campaigns endTimestamp are filtered
      * @returns

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

@@ -1,9 +1,58 @@
 import type { CampaignUnique, CampaignWithParams, CreateCampaignModel, GetCampaignQueryModel, UpdateCampaignModel, UpdateMetaDataCampaignModel } from "./";
-import { CampaignRepository } from "./campaign.repository";
 import { Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import { CampaignRepository } from "./campaign.repository";
 export declare abstract class CampaignService {
     static hashId(campaign: CampaignUnique): string;
     static splitIdOrThrow(chainAndCampaignId: `${number}-${string}` | string): CampaignUnique;
+    static getPastCampaigns(chainId?: number): Promise<{
+        type: string;
+        id: string;
+        params: import("database/api/.generated/runtime/library").JsonValue;
+        subType: number | null;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        computeChainId: number;
+        distributionChainId: number;
+        campaignId: string;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        creatorAddress: string;
+    }[]>;
+    static getLiveCampaigns(query?: {
+        computeChainId?: number;
+        type?: string;
+    }): Promise<({
+        Opportunity: {
+            name: string;
+            type: string;
+            id: string;
+            status: import("../../../../database/api/.generated").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            chainId: number;
+            action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        };
+    } & {
+        type: string;
+        id: string;
+        params: import("database/api/.generated/runtime/library").JsonValue;
+        subType: number | null;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        computeChainId: number;
+        distributionChainId: number;
+        campaignId: string;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        creatorAddress: string;
+    })[]>;
     static create(campaign: Omit<CreateCampaignModel, "id">): Promise<{
         type: string;
         id: string;
@@ -46,6 +95,11 @@ export declare abstract class CampaignService {
      * @dev back-office function
      */
     static moveToOpportunity(campaign: Omit<UpdateCampaignModel, "id">, upsert?: boolean): Promise<string>;
+    /**
+     * Get the list of campaigns satisfying the query
+     * @param query
+     * @returns A list of campaigns
+     */
     static findMany(query: GetCampaignQueryModel): Promise<{
         params: any;
         chain: {
@@ -228,9 +282,9 @@ export declare abstract class CampaignService {
      * Convert raw
      * @param query
      * @returns A list of opportunities
-     * TODO: remove this function in favor of prisma client extensions
+     * TODO: remove CampaignService function in favor of prisma client extensions
      */
-    static format(campaign: NonNullable<Awaited<ReturnType<typeof CampaignRepository.findMany>>>[number]): {
+    static format(campaign: NonNullable<Awaited<ReturnType<(typeof CampaignRepository)["findMany"]>>>[number]): {
         params: any;
         chain: {
             name: string;

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

@@ -1,6 +1,5 @@
 import { HttpError } from "../../../errors";
 import { campaignsDynamicData } from "../../../libs/campaigns/campaignsDynamicData";
-import { CampaignRepository } from "./campaign.repository";
 import { OpportunityService } from "../opportunity";
 import { StatusService } from "../status/status.service";
 import { TokenRepository } from "../token/token.repository";
@@ -11,6 +10,7 @@ import { log } from "../../../utils/logger";
 import { Campaign as CampaignEnum, NETWORK_LABELS, } from "@sdk";
 import { utils } from "ethers";
 import moment from "moment";
+import { CampaignRepository } from "./campaign.repository";
 export class CampaignService {
     static hashId(campaign) {
         return Bun.hash(`${campaign.distributionChain}${campaign.campaignId}`).toString();
@@ -21,6 +21,12 @@ export class CampaignService {
         const [chainId, campaignId] = chainAndCampaignId.split("-");
         return { distributionChain: +chainId, campaignId };
     }
+    static async getPastCampaigns(chainId) {
+        return await CampaignRepository.getPastCampaigns(chainId);
+    }
+    static async getLiveCampaigns(query) {
+        return await CampaignRepository.getLiveCampaigns(query);
+    }
     static async create(campaign) {
         const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
         await OpportunityService.createFromCampaign(campaign);
@@ -81,7 +87,7 @@ export class CampaignService {
                 .slice(0, 42);
         }
         if (campaign.opportunityIdentifier === undefined) {
-            throw new HttpError("Bad Request: opportunityIdentifier is required for this campaign type", 400);
+            throw new HttpError("Bad Request: opportunityIdentifier is required for CampaignService campaign type", 400);
         }
         const updatedCampaign = {
             ...existingCampaign,
@@ -115,6 +121,11 @@ export class CampaignService {
         // Return new opportunityId
         return (await CampaignService.findUniqueOrThrow(campaign)).opportunityId;
     }
+    /**
+     * Get the list of campaigns satisfying the query
+     * @param query
+     * @returns A list of campaigns
+     */
     static async findMany(query) {
         if (query.subType && !query.type) {
             throw new HttpError("Bad Request: Cannot specify a subType without a type", 400);
@@ -156,9 +167,7 @@ export class CampaignService {
     }
     static async findNextCampaignToProcess(chainId) {
         const campaigns = await CampaignService.findCampaignsToProcess(chainId);
-        return {
-            campaignId: campaigns?.[0]?.campaignId,
-        };
+        return { campaignId: campaigns?.[0]?.campaignId };
     }
     static async pickCampaignToProcess(chainId) {
         const campaigns = await CampaignService.findCampaignsToProcess(chainId);
@@ -241,7 +250,7 @@ export class CampaignService {
      * Convert raw
      * @param query
      * @returns A list of opportunities
-     * TODO: remove this function in favor of prisma client extensions
+     * TODO: remove CampaignService function in favor of prisma client extensions
      */
     static format(campaign) {
         const { DistributionChain, ComputeChain, RewardToken, params, CampaignStatus, ...c } = campaign;

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

@@ -1,3 +1,2 @@
 export * from "./campaign.model";
 export * from "./campaign.service";
-export * from "./campaign.controller";

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

@@ -1,3 +1,2 @@
 export * from "./campaign.model";
 export * from "./campaign.service";
-export * from "./campaign.controller";

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

@@ -22,17 +22,8 @@ export declare const ChainController: Elysia<"/chains", false, {
                 query: unknown;
                 headers: unknown;
                 response: {
-                    200: {
-                        name: string;
-                        id: number;
-                        icon: string;
-                        explorers: {
-                            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
-                            url: string;
-                            id: string;
-                            chainId: number;
-                        }[];
-                    } | null;
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };
@@ -48,17 +39,8 @@ export declare const ChainController: Elysia<"/chains", false, {
                 };
                 headers: unknown;
                 response: {
-                    200: {
-                        name: string;
-                        id: number;
-                        icon: string;
-                        explorers: {
-                            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
-                            url: string;
-                            id: string;
-                            chainId: number;
-                        }[];
-                    }[];
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };
@@ -74,7 +56,8 @@ export declare const ChainController: Elysia<"/chains", false, {
                 };
                 headers: unknown;
                 response: {
-                    200: number;
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };
@@ -85,6 +68,8 @@ export declare const ChainController: Elysia<"/chains", false, {
             patch: {
                 body: {
                     icon?: string | undefined;
+                    dailyRewards?: number | undefined;
+                    liveCampaigns?: number | undefined;
                 };
                 params: {
                     chainId: number;
@@ -94,11 +79,8 @@ export declare const ChainController: Elysia<"/chains", false, {
                     authorization: string;
                 };
                 response: {
-                    200: {
-                        name: string;
-                        id: number;
-                        icon: string;
-                    };
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };
@@ -120,14 +102,8 @@ export declare const ChainController: Elysia<"/chains", false, {
                     authorization: string;
                 };
                 response: {
-                    200: {
-                        Explorer: {
-                            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
-                            url: string;
-                            id: string;
-                            chainId: number;
-                        }[];
-                    };
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };

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

@@ -1,12 +1,14 @@
 import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
+import { apiDbClient } from "../../../utils/prisma";
 import Elysia, { t } from "elysia";
+import { initChainService } from ".";
 import { ChainResourceDto, ChainUniqueDto, CreateChainDto, GetChainQueryDto, UpdateChainDto, } from "./chain.model";
-import { ChainService } from "./chain.service";
+const chainService = initChainService(apiDbClient);
 // ─── Chains Controller ───────────────────────────────────────────────────────
 export const ChainController = new Elysia({ prefix: "/chains", detail: { tags: ["Chains"] } })
     // ─── Get A Chain By Id ───────────────────────────────────────────────
     .get("/:chainId", async ({ params: { chainId } }) => {
-    const chain = await ChainService.get(chainId);
+    const chain = await chainService.get(chainId);
     if (!chain)
         return null;
     const { Explorer, ...rest } = chain;
@@ -17,7 +19,7 @@ export const ChainController = new Elysia({ prefix: "/chains", detail: { tags: [
 })
     // ─── Get All Supported Chains ────────────────────────────────────────
     .get("/", async ({ query }) => {
-    const chains = await ChainService.findMany(query);
+    const chains = await chainService.findMany(query);
     return chains.map(({ Explorer, ...chain }) => ({ explorers: Explorer, ...chain }));
 }, {
     query: GetChainQueryDto,
@@ -25,18 +27,18 @@ export const ChainController = new Elysia({ prefix: "/chains", detail: { tags: [
     detail: { description: "List chains supported and integrated by Merkl." },
 })
     // ─── Count Chains ────────────────────────────────────────
-    .get("/count", async ({ query }) => await ChainService.countMany(query), {
+    .get("/count", async ({ query }) => await chainService.countMany(query), {
     query: GetChainQueryDto,
     detail: { hide: true },
 })
-    .patch("/:chainId", async ({ params, body }) => await ChainService.update(params.chainId, body), {
+    .patch("/:chainId", async ({ params, body }) => await chainService.update(params.chainId, body), {
     params: ChainUniqueDto,
     body: UpdateChainDto,
     headers: AuthorizationHeadersDto,
     beforeHandle: BackOfficeGuard,
     detail: { hide: true },
 })
-    .post("/", async ({ body }) => await ChainService.create(body), {
+    .post("/", async ({ body }) => await chainService.create(body), {
     body: CreateChainDto,
     headers: AuthorizationHeadersDto,
     beforeHandle: BackOfficeGuard,

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

@@ -24,6 +24,8 @@ export declare const ChainArrayOptionalDto: import("@sinclair/typebox").TObject<
 }>;
 export declare const UpdateChainDto: import("@sinclair/typebox").TObject<{
     icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    dailyRewards: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    liveCampaigns: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;
 export declare const CreateChainDto: import("@sinclair/typebox").TObject<{
     id: import("@sinclair/typebox").TNumber;