@merkl/api 0.10.352 → 0.10.354

package/dist/src/jobs/breakdowns.js

@@ -0,0 +1,55 @@
+import { CampaignService, TokenService } from "../modules/v4";
+import { BucketService } from "../modules/v4/bucket/bucket.service";
+import { RewardService } from "../modules/v4/reward";
+import { log } from "../utils/logger";
+import { apiDbClient } from "../utils/prisma";
+import moment from "moment";
+// @dev Trigger at the end of the rewards job
+export const writeBreakdownsToAPI = async (chainId, root) => {
+    const start = moment().unix();
+    const environmentName = process.env.ENV === "staging" ? "staging" : "production";
+    const breakdownBatches = [[]];
+    const breakdownBatchPromises = [];
+    let currentBreakdownBatchIndex = 0;
+    const pushBreakdowns = async (index) => {
+        log.local(`pushing breakdown batch ${index} (${breakdownBatches[index].length} points) to API DB`);
+        // Upsert users in case they don't exist yet
+        const breakdownsToCreate = [];
+        for (const b of breakdownBatches[index]) {
+            const campaignId = CampaignService.hashId({ distributionChain: chainId, campaignId: b.campaignId });
+            const rewardTokenId = TokenService.hashId({ chainId, address: b.token });
+            const rewardId = RewardService.hashId(root, b.recipient, rewardTokenId);
+            breakdownsToCreate.push({
+                rewardId,
+                protocolId: b.protocolId ? b.protocolId : undefined,
+                campaignId,
+                reason: b.reason ? b.reason : "",
+                amount: b.amount,
+                claimed: b.claimed,
+                pending: b.pending,
+                auxiliaryData1: b.auxiliaryData1 ?? "",
+                auxiliaryData2: b.auxiliaryData2 ?? "",
+            });
+        }
+        return (await apiDbClient.rewardBreakdown.createMany({
+            data: breakdownsToCreate,
+            skipDuplicates: true, // To avoid revert if data already exists
+        })).count;
+    };
+    await BucketService.readStreamFromBucket(`breakdowns/${chainId}-${root}.gz`, `merkl-rewards-lake-${environmentName}`, `merkl-data-${environmentName}`, async (x) => {
+        const breakdowns = JSON.parse(x);
+        for (const b of breakdowns) {
+            breakdownBatches[currentBreakdownBatchIndex].push(b);
+            if (breakdownBatches[currentBreakdownBatchIndex].length >= 30_000) {
+                breakdownBatchPromises.push(pushBreakdowns(currentBreakdownBatchIndex));
+                breakdownBatches.push([]);
+                currentBreakdownBatchIndex++;
+            }
+        }
+        return;
+    });
+    // Final batch
+    breakdownBatchPromises.push(pushBreakdowns(currentBreakdownBatchIndex));
+    const breakdownsCreated = (await Promise.all(breakdownBatchPromises)).reduce((acc, x) => acc + x, 0);
+    log.info(`✅ Successfully created ${breakdownsCreated} breakdowns in ${moment().unix() - start}sec`);
+};

package/dist/src/jobs/etl/pendings.d.ts

@@ -0,0 +1 @@
+export declare const main: () => Promise<void>;

package/dist/src/jobs/etl/pendings.js

@@ -0,0 +1,74 @@
+// ─── Pendings ETL ─────────────────────────────────────────────────────────────
+if (!process.env.ENV || !process.env.FILENAME)
+    throw new Error("[ENV]: missing variable");
+import { BucketService } from "../../modules/v4/bucket/bucket.service";
+import { RewardService } from "../../modules/v4/reward";
+import moment from "moment";
+import { log } from "../../utils/logger";
+// ─── Constants ───────────────────────────────────────────────
+const BATCH_SIZE = 20_000;
+// ─── Global Variables ────────────────────────────────────────
+const [chainIdString, root, campaignId] = process.env.FILENAME.split("_");
+const chainId = Number.parseInt(chainIdString);
+const pendingsToCreate = [[]];
+const failedBatches = [];
+// ─── Extract ─────────────────────────────────────────────────────────────────
+const extract = async () => {
+    let count = 0;
+    let currentBatchIndex = 0;
+    await BucketService.readStreamFromBucket(`pendings/${process.env.FILENAME}.gz`, `merkl-rewards-lake-${process.env.ENV}`, `merkl-data-${process.env.ENV}`, async (x) => {
+        pendingsToCreate[currentBatchIndex].push(transform(JSON.parse(x)));
+        if (pendingsToCreate[currentBatchIndex].length >= BATCH_SIZE) {
+            try {
+                count += await load(pendingsToCreate[currentBatchIndex]);
+                log.info(`Successfully inserted a batch of ${count} rewards`);
+            }
+            catch (err) {
+                console.error(`Failed to insert a batch, adding it to the fail queue.\n${err}`);
+                failedBatches.push(currentBatchIndex);
+            }
+            currentBatchIndex++;
+            pendingsToCreate.push([]);
+        }
+        return;
+    });
+    // ─── Current Batch Not In DB Yet ─────────────────────────────────────
+    try {
+        const count = await load(pendingsToCreate[currentBatchIndex]);
+        if (count !== 0)
+            log.info(`Successfully inserted a batch of ${count} rewards`);
+    }
+    catch (err) {
+        console.error(`Failed to insert a batch, adding it to the fail queue.\n${err}`);
+        failedBatches.push(currentBatchIndex);
+    }
+    return count;
+};
+// ─── Transform ───────────────────────────────────────────────────────────────
+const transform = (pending) => {
+    return pending;
+};
+// ─── Load ────────────────────────────────────────────────────────────────────
+const load = async (pendings) => {
+    const { updated, created } = await RewardService.updatePendings({
+        distributionChainId: chainId,
+        rewardToken: pendings[0].rewardToken,
+        campaignId,
+        root,
+        data: pendings,
+    });
+    return updated + created;
+};
+// ─────────────────────────────────────────────────────────────────────────────
+export const main = async () => {
+    const start = moment().unix();
+    // ─── Start Rewards ETL ───────────────────────────────────────────────
+    const count = await extract();
+    log.info(`✅ Successfully created ${count} new records in ${moment().unix() - start} sec`);
+    if (failedBatches.length !== 0)
+        log.info(`${failedBatches.length}/${pendingsToCreate.length} batches failed.`);
+    if (failedBatches.length === 0) {
+        await BucketService.deleteFile(`rewards/${process.env.FILENAME}.gz`, `merkl-rewards-lake-${process.env.ENV}`, `merkl-data-${process.env.ENV}`);
+    }
+};
+main();

package/dist/src/jobs/etl/reward-breakdowns.d.ts

@@ -0,0 +1 @@
+export declare const main: () => Promise<void>;

package/dist/src/jobs/etl/reward-breakdowns.js

@@ -0,0 +1,82 @@
+// ─── Reward Breakdowns ETL ───────────────────────────────────────────────────
+if (!process.env.ENV || !process.env.CHAIN_ID || !process.env.ROOT)
+    throw new Error("[ENV]: missing variable");
+import { BucketService } from "../../modules/v4/bucket/bucket.service";
+import { log } from "../../utils/logger";
+import { apiDbClient } from "../../utils/prisma";
+import moment from "moment";
+// ─── Constants ───────────────────────────────────────────────
+const BATCH_SIZE = 30_000;
+// ─── Global Variables ────────────────────────────────────────
+const rewardBreakdownsToCreate = [[]];
+const failedBatches = [];
+// ─── Extract ─────────────────────────────────────────────────────────────────
+const extract = async () => {
+    let currentBatchIndex = 0;
+    let count = 0;
+    await BucketService.readStreamFromBucket(`breakdowns/${process.env.CHAIN_ID}-${process.env.ROOT}.gz`, `merkl-rewards-lake-${process.env.ENV}`, `merkl-data-${process.env.ENV}`, async (x) => {
+        const breakdowns = JSON.parse(x);
+        for (const breakdown of breakdowns) {
+            rewardBreakdownsToCreate[currentBatchIndex].push(transform(breakdown));
+            if (rewardBreakdownsToCreate[currentBatchIndex].length >= BATCH_SIZE) {
+                try {
+                    count += await load(rewardBreakdownsToCreate[currentBatchIndex]);
+                }
+                catch (err) {
+                    console.error(`Failed to insert a batch, adding it to the fail queue.\n${err}`);
+                    failedBatches.push(currentBatchIndex);
+                }
+                currentBatchIndex++;
+                rewardBreakdownsToCreate.push([]);
+            }
+        }
+        return;
+    });
+    // ─── Current Batch Not In DB Yet ─────────────────────────────────────
+    try {
+        const count = await load(rewardBreakdownsToCreate[currentBatchIndex]);
+        if (count !== 0)
+            log.info(`Successfully inserted a batch of ${count} rewards`);
+    }
+    catch (err) {
+        console.error(`Failed to insert a batch, adding it to the fail queue.\n${err}`);
+        failedBatches.push(currentBatchIndex);
+    }
+    return count;
+};
+// ─── Transform ───────────────────────────────────────────────────────────────
+const transform = (rewardBreakdown) => {
+    const campaignId = Bun.hash(`${process.env.CHAIN_ID}${rewardBreakdown.campaignId}`).toString();
+    const rewardTokenId = Bun.hash(`${process.env.CHAIN_ID}${rewardBreakdown.token}`).toString();
+    const rewardId = Bun.hash(`${process.env.ROOT}${rewardBreakdown.recipient}${rewardTokenId}`).toString();
+    return {
+        rewardId,
+        protocolId: rewardBreakdown.protocolId ? rewardBreakdown.protocolId : undefined,
+        campaignId,
+        reason: rewardBreakdown.reason ? rewardBreakdown.reason : "",
+        amount: rewardBreakdown.amount,
+        claimed: rewardBreakdown.claimed,
+        pending: rewardBreakdown.pending,
+        auxiliaryData1: rewardBreakdown.auxiliaryData1 ?? "",
+        auxiliaryData2: rewardBreakdown.auxiliaryData2 ?? "",
+    };
+};
+// ─── Load ────────────────────────────────────────────────────────────────────
+const load = async (rewardBreakdowns) => {
+    return (await apiDbClient.rewardBreakdown.createMany({
+        data: rewardBreakdowns,
+        skipDuplicates: true,
+    })).count;
+};
+// ─── Main ────────────────────────────────────────────────────────────────────
+export const main = async () => {
+    const start = moment().unix();
+    const count = await extract();
+    log.info(`✅ Successfully created ${count} new records in ${moment().unix() - start} sec`);
+    if (failedBatches.length !== 0)
+        log.info(`${failedBatches.length}/${rewardBreakdownsToCreate.length} batches failed.`);
+    if (failedBatches.length === 0) {
+        await BucketService.deleteFile(`rewards/${process.env.CHAIN_ID}-${process.env.ROOT}.gz`, `merkl-rewards-lake-${process.env.ENV}`, `merkl-data-${process.env.ENV}`);
+    }
+};
+main();

package/dist/src/jobs/etl/rewards.d.ts

@@ -0,0 +1 @@
+export declare const main: () => Promise<void>;

package/dist/src/jobs/etl/rewards.js

@@ -0,0 +1,102 @@
+// ─── Rewards ETL ─────────────────────────────────────────────────────────────
+if (!process.env.ENV || !process.env.CHAIN_ID || !process.env.ROOT)
+    throw new Error("[ENV]: missing variable");
+import { BucketService } from "../../modules/v4/bucket/bucket.service";
+import { log } from "../../utils/logger";
+import { apiDbClient } from "../../utils/prisma";
+import moment from "moment";
+// ─── Constants ───────────────────────────────────────────────
+const BATCH_SIZE = 20_000;
+// ─── Global Variables ────────────────────────────────────────
+const rewardsToCreate = [[]];
+const failedBatches = [];
+// ─── Extract ─────────────────────────────────────────────────────────────────
+const extract = async () => {
+    let count = 0;
+    let currentBatchIndex = 0;
+    await BucketService.readStreamFromBucket(`rewards/${process.env.CHAIN_ID}-${process.env.ROOT}.gz`, `merkl-rewards-lake-${process.env.ENV}`, `merkl-data-${process.env.ENV}`, async (x) => {
+        rewardsToCreate[currentBatchIndex].push(transform(JSON.parse(x)));
+        if (rewardsToCreate[currentBatchIndex].length >= BATCH_SIZE) {
+            try {
+                count += await load(rewardsToCreate[currentBatchIndex]);
+                log.info(`Successfully inserted a batch of ${count} rewards`);
+            }
+            catch (err) {
+                console.error(`Failed to insert a batch, adding it to the fail queue.\n${err}`);
+                failedBatches.push(currentBatchIndex);
+            }
+            currentBatchIndex++;
+            rewardsToCreate.push([]);
+        }
+        return;
+    });
+    // ─── Current Batch Not In DB Yet ─────────────────────────────────────
+    try {
+        const count = await load(rewardsToCreate[currentBatchIndex]);
+        if (count !== 0)
+            log.info(`Successfully inserted a batch of ${count} rewards`);
+    }
+    catch (err) {
+        console.error(`Failed to insert a batch, adding it to the fail queue.\n${err}`);
+        failedBatches.push(currentBatchIndex);
+    }
+    return count;
+};
+// ─── Transform ───────────────────────────────────────────────────────────────
+const transform = (reward) => {
+    const rewardTokenId = Bun.hash(`${process.env.CHAIN_ID}${reward.rewardToken}`).toString();
+    const id = Bun.hash(`${process.env.ROOT}${reward.recipient}${rewardTokenId}`).toString();
+    return {
+        id,
+        root: reward.root,
+        amount: reward.amount,
+        pending: reward.pending,
+        claimed: reward.claimed,
+        recipient: reward.recipient,
+        rewardTokenId,
+        proofs: reward.proofs,
+    };
+};
+// ─── Load ────────────────────────────────────────────────────────────────────
+const load = async (rewards) => {
+    // ─── Load Users ──────────────────────────────────────────────────────
+    await apiDbClient.user.createMany({
+        data: rewards.map(r => {
+            return {
+                address: r.recipient,
+            };
+        }),
+        skipDuplicates: true,
+    });
+    // ─── Load Rewards ────────────────────────────────────────────────────
+    return (await apiDbClient.reward.createMany({
+        data: rewards,
+        skipDuplicates: true,
+    })).count;
+};
+// ─────────────────────────────────────────────────────────────────────────────
+export const main = async () => {
+    const start = moment().unix();
+    // ─── Create Merkle Root If Not Exists ────────────────────────────────
+    await apiDbClient.merklRoot.upsert({
+        create: {
+            root: process.env.ROOT,
+            chainId: +process.env.CHAIN_ID,
+            epoch: Math.floor(start / 3_600),
+            timestamp: start,
+        },
+        update: {},
+        where: {
+            root: process.env.ROOT,
+        },
+    });
+    // ─── Start Rewards ETL ───────────────────────────────────────────────
+    const count = await extract();
+    log.info(`✅ Successfully created ${count} new records in ${moment().unix() - start} sec`);
+    if (failedBatches.length !== 0)
+        log.info(`${failedBatches.length}/${rewardsToCreate.length} batches failed.`);
+    if (failedBatches.length === 0) {
+        await BucketService.deleteFile(`rewards/${process.env.CHAIN_ID}-${process.env.ROOT}.gz`, `merkl-rewards-lake-${process.env.ENV}`, `merkl-data-${process.env.ENV}`);
+    }
+};
+main();

package/dist/src/jobs/rewards.d.ts

@@ -0,0 +1 @@
+export declare const writeRewardsToAPI: (chainId: number, root: string) => Promise<void>;

package/dist/src/jobs/rewards.js

@@ -0,0 +1,74 @@
+import { TokenService } from "../modules/v4";
+import { BucketService } from "../modules/v4/bucket/bucket.service";
+import { RewardService } from "../modules/v4/reward";
+import { log } from "../utils/logger";
+import { apiDbClient } from "../utils/prisma";
+import { HOUR } from "@sdk";
+import moment from "moment";
+import { writeBreakdownsToAPI } from "./breakdowns";
+export const writeRewardsToAPI = async (chainId, root) => {
+    const start = moment().unix();
+    const environmentName = process.env.ENV === "staging" ? "staging" : "production";
+    const now = moment().unix();
+    // Upsert root
+    await apiDbClient.merklRoot.upsert({
+        create: {
+            root,
+            chainId,
+            epoch: Math.floor(now / HOUR),
+            timestamp: now,
+        },
+        update: {},
+        where: {
+            root,
+        },
+    });
+    // Read reward stream and populate the table
+    const rewardBatches = [[]];
+    const rewardBatchPromises = [];
+    let currentRewardBatchIndex = 0;
+    const pushRewards = async (index) => {
+        log.local(`pushing rewards batch ${index} (${rewardBatches[index].length} points) to API DB`);
+        // Upsert users in case they don't exist yet
+        await apiDbClient.user.createMany({
+            data: rewardBatches[index].map(r => {
+                return {
+                    address: r.recipient,
+                };
+            }),
+            skipDuplicates: true,
+        });
+        const rewardsToCreate = rewardBatches[index].map(reward => {
+            const rewardTokenId = TokenService.hashId({ chainId, address: reward.rewardToken });
+            const id = RewardService.hashId(root, reward.recipient, rewardTokenId);
+            return {
+                id,
+                root: reward.root,
+                amount: reward.amount,
+                pending: reward.pending,
+                claimed: reward.claimed,
+                recipient: reward.recipient,
+                rewardTokenId,
+                proofs: reward.proofs,
+            };
+        });
+        return (await apiDbClient.reward.createMany({
+            data: rewardsToCreate,
+            skipDuplicates: true, // To avoid revert if data already exists
+        })).count;
+    };
+    await BucketService.readStreamFromBucket(`rewards/${chainId}-${root}.gz`, `merkl-rewards-lake-${environmentName}`, `merkl-data-${environmentName}`, async (x) => {
+        rewardBatches[currentRewardBatchIndex].push(JSON.parse(x));
+        if (rewardBatches[currentRewardBatchIndex].length >= 20_000) {
+            rewardBatchPromises.push(pushRewards(currentRewardBatchIndex));
+            currentRewardBatchIndex++;
+            rewardBatches.push([]);
+        }
+        return;
+    });
+    // Final batch
+    rewardBatchPromises.push(pushRewards(currentRewardBatchIndex));
+    const rewardsCreated = (await Promise.all(rewardBatchPromises)).reduce((acc, x) => acc + x, 0);
+    log.info(`✅ Successfully created ${rewardsCreated} rewards in ${moment().unix() - start}sec`);
+    await writeBreakdownsToAPI(chainId, root);
+};

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

@@ -18,18 +18,22 @@ export type callKeys = mandatoryCallKeys & {
     [key: string]: string;
 };
 export type mandatoryCallKeys = {
+    type: tokenType;
+    protocol: string;
     tokenAddress: string;
     blacklistedSupply: string;
     totalSupply: string;
     whitelistedSupply: string;
 };
 export type dataRaw = {
+    protocol: string;
     tokenAddress: string;
     blacklistedSupply: string;
     totalSupply: string;
     whitelistedSupply: string;
 };
 export type dataType = {
+    protocol: string;
     type: tokenType;
     tokenAddress: string;
     totalSupply: number;

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

@@ -39,6 +39,7 @@ export class GenericProcessor {
         const priceTargetToken = (await pricer.get({ symbol: campaign.campaignParameters.symbolTargetToken })) ?? 0;
         const tvl = whitelistedSupplyTargetToken * priceTargetToken;
         return {
+            protocol: typeInfo.protocol,
             type,
             whitelistedSupplyTargetToken,
             totalSupply,
@@ -49,7 +50,7 @@ export class GenericProcessor {
         };
     }
     computeRound1(type, typeInfo) {
-        typeInfo = { ...tokenTypeToProtocol[type], ...typeInfo };
+        typeInfo = { type, ...tokenTypeToProtocol[type], ...typeInfo };
         this.processingRound1(typeInfo);
         if (this.debug) {
             console.log("Round 1", {

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

@@ -1,5 +1,8 @@
 import type { SaveData } from "node_modules/@google-cloud/storage/build/esm/src/file";
 export declare abstract class BucketService {
-    private static storage;
     static upload(bucketName: string, filename: string, data: SaveData, isPublic: boolean): Promise<string>;
+    static writeStreamToBucket<T>(data: T[], fileName: string, bucketName: string, projectID?: string, hook?: (data: T) => string, isPublic?: boolean, withLog?: boolean): Promise<void>;
+    static readStreamFromBucket<T>(fileName: string, bucketName: string, projectID?: string, hook?: (line: string) => T, withLog?: boolean): Promise<T[]>;
+    static deleteFile(fileName: string, bucketName: string, projectID: string): Promise<void>;
+    static exists(fileName: string, bucketName: string, projectID: string): Promise<boolean>;
 }

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

@@ -1,11 +1,92 @@
+import { log } from "../../../utils/logger";
 import { Storage } from "@google-cloud/storage";
 export class BucketService {
-    static storage = new Storage({ projectId: "angle-production-1" });
     static async upload(bucketName, filename, data, isPublic) {
-        const file = await BucketService.storage.bucket(bucketName).file(filename);
+        const storage = new Storage({ projectId: "angle-production-1" });
+        const file = await storage.bucket(bucketName).file(filename);
         await file.save(data);
         if (isPublic)
             await file.makePublic();
         return `https://storage.googleapis.com/${bucketName}/${filename}`;
     }
+    static async writeStreamToBucket(data, fileName, bucketName, projectID, hook = JSON.stringify, isPublic = false, withLog = true) {
+        const storage = new Storage({ projectId: projectID });
+        const bucket = storage.bucket(bucketName);
+        const file = bucket.file(fileName);
+        const [exist] = await file.exists();
+        if (exist) {
+            await file.delete();
+        }
+        await file.save("", { resumable: false });
+        await file.setMetadata({
+            cacheControl: "public, max-age=300",
+        });
+        if (isPublic) {
+            await file.makePublic();
+        }
+        const writeStream = file.createWriteStream({
+            resumable: false,
+            gzip: true, // Enable gzip compression
+        });
+        const streamPromise = new Promise((resolve, reject) => {
+            writeStream.on("error", reject);
+            writeStream.on("finish", resolve);
+        });
+        for (const d of data) {
+            await writeStream.write(`${hook(d)}\n`);
+        }
+        await writeStream.end();
+        await streamPromise;
+        withLog && log.local(`✅ successfully updated https://storage.cloud.google.com/${bucketName}/${fileName}`);
+    }
+    static async readStreamFromBucket(fileName, bucketName, projectID, hook = line => JSON.parse(line), withLog = true) {
+        const storage = new Storage({ projectId: projectID });
+        const bucket = storage.bucket(bucketName);
+        const file = bucket.file(fileName);
+        const [exists] = await file.exists();
+        if (!exists) {
+            throw new Error(`File ${fileName} does not exist in bucket ${bucketName}`);
+        }
+        return new Promise((resolve, reject) => {
+            const data = [];
+            let buffer = "";
+            file
+                .createReadStream({
+                decompress: true,
+            })
+                .on("data", async (chunk) => {
+                // instead of using callback functions here, we could use pipe streams
+                buffer += chunk.toString();
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.trim()) {
+                        const res = hook(line);
+                        data.push(res);
+                    }
+                }
+            })
+                .on("error", reject)
+                .on("end", async () => {
+                if (buffer.trim()) {
+                    const res = hook(buffer);
+                    data.push(res);
+                }
+                withLog &&
+                    log.local(`✅ Successfully read ${data.length} items from https://storage.cloud.google.com/${bucketName}/${fileName}`);
+                resolve(data);
+            });
+        });
+    }
+    static async deleteFile(fileName, bucketName, projectID) {
+        const storage = new Storage({ projectId: projectID });
+        const bucket = storage.bucket(bucketName);
+        const file = bucket.file(fileName);
+        await file.delete();
+    }
+    static async exists(fileName, bucketName, projectID) {
+        const storage = new Storage({ projectId: projectID });
+        const [exists] = await storage.bucket(bucketName).file(fileName).exists();
+        return exists;
+    }
 }

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

@@ -112,7 +112,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 body: unknown;
                 params: {};
                 query: {
-                    type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER" | "ERC20TRANSFERS" | "ERC20LOGPROCESSOR" | "ERC20REBASELOGPROCESSOR" | "VEST" | 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;
                     items?: number | undefined;
                     subType?: number | undefined;
                     page?: number | undefined;
@@ -184,7 +184,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 body: unknown;
                 params: {};
                 query: {
-                    type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER" | "ERC20TRANSFERS" | "ERC20LOGPROCESSOR" | "ERC20REBASELOGPROCESSOR" | "VEST" | 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;
                     items?: number | undefined;
                     subType?: number | undefined;
                     page?: number | undefined;

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

@@ -141,6 +141,9 @@ export declare const GetCampaignQueryDto: import("@sinclair/typebox").TObject<{
         ERC20LOGPROCESSOR: "ERC20LOGPROCESSOR";
         ERC20REBASELOGPROCESSOR: "ERC20REBASELOGPROCESSOR";
         VEST: "VEST";
+        ERC20_FIX_APR: "ERC20_FIX_APR";
+        HYPERDRIVELOGPROCESSOR: "HYPERDRIVELOGPROCESSOR";
+        HYPERDRIVELOGFIXPROCESSOR: "HYPERDRIVELOGFIXPROCESSOR";
     }>>;
     subType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     campaignId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;