@merkl/api 0.16.34 → 0.16.35

package/package.json

@@ -102,5 +102,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "v0.16.34"
+  "version": "v0.16.35"
 }

package/dist/src/backgroundJobs/jobs/priceUpdater.d.ts

@@ -1,37 +0,0 @@
-import type Elysia from "elysia";
-export declare const updatePrices: () => Promise<void>;
-export declare const priceUpdater: (app: Elysia) => Elysia<"", false, {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    type: {};
-    error: {};
-}, {
-    schema: {};
-    macro: {};
-    macroFn: {};
-}, {
-    v3: {
-        updatePrices: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}>;

package/dist/src/backgroundJobs/jobs/priceUpdater.js

@@ -1,21 +0,0 @@
-import { TokenService } from "../../modules/v4/token/token.service";
-import { log } from "../../utils/logger";
-import { Pricer } from "../../utils/pricer";
-export const updatePrices = async () => {
-    const pricer = await Pricer.load();
-    const prices = await pricer.update();
-    log.info(`✅ ${Object.keys(prices).length} prices cache updated successfully`);
-    log.info("⏳ Updating API database...");
-    await TokenService.updatePrices(pricer);
-    log.info("✅ API database updated successfully!");
-};
-export const priceUpdater = (app) => {
-    return app.get("/v3/updatePrices", async () => {
-        await updatePrices();
-        return new Response(JSON.stringify({
-            status: "success",
-        }), {
-            status: 200,
-        });
-    });
-};

package/dist/src/backgroundJobs/jobs/sync.d.ts

@@ -1,40 +0,0 @@
-import Elysia from "elysia";
-export declare const sync: Elysia<"/jobs", false, {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    type: {};
-    error: {};
-}, {
-    schema: {};
-    macro: {};
-    macroFn: {};
-}, {
-    jobs: {
-        api: {
-            "sync-with-engine": {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: void;
-                    };
-                };
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}>;

package/dist/src/backgroundJobs/jobs/sync.js

@@ -1,33 +0,0 @@
-import { AuthorizationHeadersDto, EngineGuard } from "../../guards/Engine.guard";
-import { CampaignService } from "../../modules/v4/campaign";
-import { ChainService } from "../../modules/v4/chain";
-import { log } from "../../utils/logger";
-import Elysia from "elysia";
-export const sync = new Elysia({ prefix: "/jobs" }).get("/api/sync-with-engine", async () => {
-    const chains = await ChainService.findMany({});
-    for (const chain of chains) {
-        log.info(`fetching campaigns on ${chain.name} (chainId: ${chain.id})`);
-        const campaignsV3 = await CampaignService.getFromEngineDb(chain.id, 0);
-        const campaigns = campaignsV3.map(campaignV3 => {
-            return {
-                amount: campaignV3.amount,
-                campaignId: campaignV3.campaignId,
-                chainId: campaignV3.chainId,
-                computeChainId: campaignV3.computeChainId,
-                creator: campaignV3.creator,
-                endTimestamp: campaignV3.endTimestamp.toString(),
-                opportunityIdentifier: campaignV3.mainParameter,
-                params: JSON.stringify(campaignV3.campaignParameters),
-                rewardTokenAddress: campaignV3.rewardToken,
-                startTimestamp: campaignV3.startTimestamp.toString(),
-                type: campaignV3.campaignType,
-                subType: campaignV3.campaignSubType,
-            };
-        });
-        log.info(`syncing ${campaigns.length} campaigns to sync on ${chain.name}...`);
-        const { success, fail } = await CampaignService.createMany(campaigns);
-        log.info(`${success} campaigns synced successfully on ${chain.name}`);
-        log.info(`${fail} campaigns failed to sync on ${chain.name}`);
-    }
-    return;
-}, { headers: AuthorizationHeadersDto, beforeHandle: EngineGuard });

package/dist/src/routes/v3/campaignReport.d.ts

@@ -1,43 +0,0 @@
-import { type Elysia } from "elysia";
-import { type RewardsAmountQueryOutput } from "../../utils/queries/rewardsAmount";
-export declare const query: import("@sinclair/typebox").TObject<{
-    campaignId: import("@sinclair/typebox").TString;
-    chainId: import("@sinclair/typebox").TNumber;
-}>;
-declare const _default: (app: Elysia) => Elysia<"", false, {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    type: {};
-    error: {};
-}, {
-    schema: {};
-    macro: {};
-    macroFn: {};
-}, {
-    campaignReport: {
-        get: {
-            body: unknown;
-            params: {};
-            query: {
-                chainId: number;
-                campaignId: string;
-            };
-            headers: unknown;
-            response: {
-                200: RewardsAmountQueryOutput;
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}>;
-export default _default;

package/dist/src/routes/v3/campaignReport.js

@@ -1,22 +0,0 @@
-import { engineDbClient } from "../../utils/prisma";
-import { t } from "elysia";
-import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
-import { merklChainDataWithCache } from "../../libs/merklChainData";
-import { LATEST_CAMPAIGNS_REWARDS } from "../../utils/queries/rewardsAmount";
-export const query = t.Object({
-    campaignId: t.String(),
-    chainId: t.Numeric(),
-});
-export default (app) => app.use(checkQueryChainIdValidity()).get("/campaignReport", async ({ query }) => {
-    const campaignId = query.campaignId;
-    const chainId = query.chainId;
-    const currentRoot = (await merklChainDataWithCache(chainId)).merkleRoot;
-    if (!currentRoot) {
-        return [];
-    }
-    const rewardsData = await engineDbClient.$queryRaw(LATEST_CAMPAIGNS_REWARDS(chainId, currentRoot, [campaignId]));
-    return rewardsData;
-}, {
-    query,
-    tags: ["Campaigns"],
-});

package/dist/src/routes/v3/campaignsInfo.d.ts

@@ -1,41 +0,0 @@
-import type Elysia from "elysia";
-declare const _default: (app: Elysia) => Elysia<"", false, {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    type: {};
-    error: {};
-}, {
-    schema: {};
-    macro: {};
-    macroFn: {};
-}, {
-    campaignInfo: {
-        post: {
-            body: {
-                [x: string]: string[];
-            };
-            params: {};
-            query: unknown;
-            headers: unknown;
-            response: {
-                200: {
-                    [x: string]: Record<string, any>;
-                } | {
-                    error: string;
-                };
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}>;
-export default _default;

package/dist/src/routes/v3/campaignsInfo.js

@@ -1,54 +0,0 @@
-import { Redis } from "../../cache";
-import { engineDbClient } from "../../utils/prisma";
-import { t } from "elysia";
-export default (app) => app.post("/campaignInfo", async ({ body }) => {
-    if (!body)
-        return { error: "Invalid body" };
-    const chainIds = Object.keys(body);
-    const campaigns = await engineDbClient.campaigns.findMany({
-        where: {
-            OR: chainIds.map(chainId => {
-                return {
-                    chainId: Number.parseInt(chainId),
-                    campaignId: {
-                        in: body[Number.parseInt(chainId)],
-                    },
-                };
-            }),
-        },
-    });
-    const reducedCampaigns = campaigns.reduce((acc, campaign) => {
-        acc[campaign.chainId] = acc[campaign.chainId] || {};
-        acc[campaign.chainId][campaign.campaignId] = campaign;
-        return acc;
-    }, {});
-    const chainIdsWithCampaigns = Object.keys(reducedCampaigns).map(chainId => Number.parseInt(chainId));
-    const dynamicData = (await Redis.getManyWithArgs("Campaigns", chainIdsWithCampaigns)).reduce((prev, allData, index) => {
-        if (!!allData) {
-            prev[chainIdsWithCampaigns[index]] = Object.keys(allData).reduce((acc, curr) => {
-                if (curr.split("_")[0] === "1") {
-                    acc[curr] = allData[curr];
-                }
-                return acc;
-            }, {});
-        }
-        return prev;
-    }, {});
-    for (const [chainId, data] of Object.entries(dynamicData)) {
-        for (const [, campaignsDynamicData] of Object.entries(data)) {
-            for (const [campaignId, campaignData] of Object.entries(campaignsDynamicData)) {
-                if (!!reducedCampaigns[chainId][campaignId]) {
-                    reducedCampaigns[chainId][campaignId] = {
-                        ...reducedCampaigns[chainId][campaignId],
-                        type: campaignData.type,
-                        typeInfo: campaignData.typeInfo,
-                    };
-                }
-            }
-        }
-    }
-    return reducedCampaigns;
-}, {
-    body: t.Record(t.String(), t.Array(t.String())),
-    tags: ["Campaigns"],
-});

package/dist/src/routes/v3/exports/campaigns.d.ts

@@ -1,43 +0,0 @@
-import { type Elysia } from "elysia";
-export declare const query: import("@sinclair/typebox").TObject<{
-    chainId: import("@sinclair/typebox").TNumber;
-    minIndex: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>;
-declare const _default: (app: Elysia) => Elysia<"", false, {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    type: {};
-    error: {};
-}, {
-    schema: {};
-    macro: {};
-    macroFn: {};
-}, {
-    index: {
-        get: {
-            body: unknown;
-            params: {};
-            query: {
-                minIndex?: number | undefined;
-                chainId: number;
-            };
-            headers: unknown;
-            response: {
-                [x: string]: any;
-                200: any;
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}>;
-export default _default;

package/dist/src/routes/v3/exports/campaigns.js

@@ -1,28 +0,0 @@
-import checkQueryChainIdValidity from "../../../hooks/checkQueryChainIdValidity";
-import { staticCampaignWithCache } from "../../../libs/staticCampaigns";
-import { engineDbClient } from "../../../utils/prisma";
-import { t } from "elysia";
-export const query = t.Object({
-    chainId: t.Numeric(),
-    minIndex: t.Optional(t.Numeric()),
-});
-export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
-    const chainId = query.chainId;
-    const minIndex = query.minIndex;
-    if (!!minIndex || minIndex === 0) {
-        // Query from minIndex
-        return await engineDbClient.campaigns.findMany({
-            where: {
-                chainId: chainId,
-                index: {
-                    gte: minIndex,
-                },
-            },
-        });
-    }
-    // Query all campaigns
-    return await staticCampaignWithCache(chainId);
-}, {
-    query,
-    tags: ["Campaigns"],
-});

package/dist/src/routes/v3/tokenUnclaimed.d.ts

@@ -1,44 +0,0 @@
-import { type Elysia } from "elysia";
-export declare const query: import("@sinclair/typebox").TObject<{
-    token: import("@sinclair/typebox").TString;
-    chainId: import("@sinclair/typebox").TNumber;
-}>;
-declare const _default: (app: Elysia) => Elysia<"", false, {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    type: {};
-    error: {};
-}, {
-    schema: {};
-    macro: {};
-    macroFn: {};
-}, {
-    tokenUnclaimed: {
-        get: {
-            body: unknown;
-            params: {};
-            query: {
-                token: string;
-                chainId: number;
-            };
-            headers: unknown;
-            response: {
-                200: {
-                    message: string;
-                };
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}>;
-export default _default;

package/dist/src/routes/v3/tokenUnclaimed.js

@@ -1,24 +0,0 @@
-// import type { MerklChainId } from "@sdk";
-import { t } from "elysia";
-import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
-// import { merklChainDataWithCache } from "../../libs/merklChainData";
-// import { MerkleRootNotFound } from "../../utils/error";
-// import { prisma } from "../../utils/prisma";
-// import { UNCLAIMED_BY_TOKEN } from "../../utils/queries/unclaimed";
-export const query = t.Object({
-    token: t.String(),
-    chainId: t.Numeric(),
-});
-export default (app) => app.use(checkQueryChainIdValidity()).get("/tokenUnclaimed", async ({ query }) => {
-    // const token = query.token;
-    // const chainId = query.chainId as MerklChainId;
-    // const currentRoot = (await merklChainDataWithCache(chainId)).merkleRoot;
-    // if (!currentRoot) throw new MerkleRootNotFound(chainId);
-    // return await prisma.$queryRaw(UNCLAIMED_BY_TOKEN(currentRoot, chainId, token));
-    return {
-        message: "Route removed for performance improvement, please reach out to the team for more information.",
-    };
-}, {
-    query,
-    tags: ["Rewards"],
-});

package/dist/src/utils/queries/campaignsForMainParameter.d.ts

@@ -1,2 +0,0 @@
-import { Prisma } from "../../../database/engine/.generated";
-export declare const CAMPAIGNS_BY_MAIN_PARAMETER: (chainId: number, mainParameter: string) => Prisma.Sql;

package/dist/src/utils/queries/campaignsForMainParameter.js

@@ -1,23 +0,0 @@
-import { Prisma } from "../../../database/engine/.generated";
-export const CAMPAIGNS_BY_MAIN_PARAMETER = (chainId, mainParameter) => Prisma.sql `
-    SELECT
-        campaigns."campaignId",
-        campaigns."campaignType",
-        campaigns."rewardToken",
-        tokens."symbol" as "rewardTokenSymbol",
-        CAST(campaigns."amount" as numeric) / (10^campaigns."decimalsRewardToken") as "amountDecimal",
-        campaigns."startTimestamp",
-        campaigns."endTimestamp"
-    FROM (
-        SELECT
-            "chainId", "campaignId", "campaignType", "rewardToken", "amount", "startTimestamp", "endTimestamp", CAST("campaignParameters"->>'decimalsRewardToken' as numeric) as "decimalsRewardToken"
-        FROM "Campaigns"
-        WHERE
-            "chainId" = ${chainId} AND
-            "campaignType" != 0 AND
-            LOWER("mainParameter") = LOWER(${mainParameter})
-        ORDER BY "endTimestamp" DESC
-    ) as campaigns
-    INNER JOIN "Tokens" as tokens
-    ON tokens."address"=campaigns."rewardToken" AND tokens."chainId"=campaigns."chainId"
-    `;

package/dist/src/utils/queries/claimsOverTime.d.ts

@@ -1,8 +0,0 @@
-import { Prisma } from "../../../database/engine/.generated";
-export declare const CLAIMS_OVER_TIME: (chainId: number, campaignId: string) => Prisma.Sql;
-export declare const CLAIMS_OVER_TIME_GROUPED: (chainId: number, campaignId: string) => Prisma.Sql;
-export declare const CLAIMS_OVER_TIME_V2: (chainId: number, campaignId: string) => Prisma.Sql;
-export declare const CLAIMS_FOR_CREATOR_TAG: (chainIds: number[], user: string, creatorTag: string) => Prisma.Sql;
-export declare const CLAIMS_FOR_CREATOR_TAG_GROUPED: (chainIds: number[], user: string, creatorTag: string) => Prisma.Sql;
-export declare const CLAIMS_FOR_USER: (chainIds: number[], user: string) => Prisma.Sql;
-export declare const CLAIMS_FOR_USER_GROUPED: (chainIds: number[], user: string) => Prisma.Sql;

package/dist/src/utils/queries/claimsOverTime.js

@@ -1,111 +0,0 @@
-import { Prisma } from "../../../database/engine/.generated";
-export const CLAIMS_OVER_TIME = (chainId, campaignId) => Prisma.sql `
-    SELECT timestamp, recipient, reason, claimed
-    FROM "ClaimsOverTime"
-    WHERE
-        "chainId"=${chainId} AND
-        "campaignId"=${campaignId} 
-    ORDER BY timestamp ASC
-    `;
-export const CLAIMS_OVER_TIME_GROUPED = (chainId, campaignId) => Prisma.sql `
-    SELECT timestamp, recipient, SUM(CAST(claimed as numeric)) as claimed
-    FROM "ClaimsOverTime"
-    WHERE
-        "chainId"=${chainId} AND
-        "campaignId"=${campaignId} 
-    GROUP BY timestamp, recipient
-    ORDER BY timestamp ASC
-    `;
-export const CLAIMS_OVER_TIME_V2 = (chainId, campaignId) => Prisma.sql `
-
-    SELECT cot.timestamp, cot.recipient, cot.reason, cot.claimed, COALESCE(cc.label, 'unknown') FROM (
-        SELECT *
-        FROM "ClaimsOverTime"
-        WHERE
-            "chainId"=${chainId} AND
-            "campaignId"=${campaignId} 
-                ) as cot
-        LEFT JOIN (
-            SELECT "campaignId", "creator", "mainParameter"
-            FROM "Campaigns"
-            WHERE
-                "chainId"=${chainId} AND
-                "campaignId"=${campaignId} 
-            ) as campaigns
-        ON cot."campaignId"=campaigns."campaignId"
-        LEFT JOIN
-            "CampaignCreators" as cc
-        ON campaigns.creator=cc.address
-    `;
-export const CLAIMS_FOR_CREATOR_TAG = (chainIds, user, creatorTag) => Prisma.sql `
-    SELECT cc."chainId", cc.timestamp, cc.recipient, cc.reason, cc."rewardToken" as token, cc."campaignId", t.symbol, t.decimals, cc.claimed FROM (
-        SELECT "chainId", timestamp, recipient, reason, "campaignId", "rewardToken", CAST(claimed AS text) as claimed
-        FROM "ClaimsOverTime"
-        WHERE
-            "chainId" IN (${Prisma.join(chainIds)}) AND
-            "recipient"=${user} AND
-            "campaignId" IN (
-                SELECT
-                    "campaignId"
-                FROM "Campaigns"
-                WHERE
-                    "campaignType" != 0 AND
-                    "chainId" IN (${Prisma.join(chainIds)}) AND
-                    creator IN (
-                        SELECT address from "CampaignCreators" WHERE tags LIKE ${`%${creatorTag}%`}
-                    )
-            )
-    ) as cc
-     LEFT JOIN "Tokens" as t
-     ON cc."chainId"=t."chainId" AND cc."rewardToken"=t.address
-     ORDER BY cc.timestamp ASC
-    `;
-export const CLAIMS_FOR_CREATOR_TAG_GROUPED = (chainIds, user, creatorTag) => Prisma.sql `
-    SELECT cc."chainId", cc.timestamp, cc.recipient, cc."campaignId", cc."rewardToken" as token, t.symbol, t.decimals, cc.claimed FROM (
-        SELECT "chainId", timestamp, recipient, "rewardToken", "campaignId", CAST(SUM(CAST(claimed AS numeric)) AS text) as claimed
-        FROM "ClaimsOverTime"
-        WHERE
-            "chainId" IN (${Prisma.join(chainIds)}) AND
-            "recipient"=${user} AND
-            "campaignId" IN (
-                SELECT
-                    "campaignId"
-                FROM "Campaigns"
-                WHERE
-                    "campaignType" != 0 AND
-                    "chainId" IN (${Prisma.join(chainIds)}) AND
-                    creator IN (
-                        SELECT address from "CampaignCreators" WHERE tags LIKE ${`%${creatorTag}%`}
-                    )
-            )
-        GROUP BY timestamp, recipient, "chainId", "rewardToken", "campaignId"
-    ) as cc
-     LEFT JOIN "Tokens" as t
-     ON cc."chainId"=t."chainId" AND cc."rewardToken"=t.address
-     ORDER BY cc.timestamp ASC
-    `;
-export const CLAIMS_FOR_USER = (chainIds, user) => Prisma.sql `
-    SELECT cc."chainId", cc.timestamp, cc.recipient, cc.reason, cc."campaignId", cc."rewardToken" as token, t.symbol, t.decimals, cc.claimed FROM (
-        SELECT "chainId", timestamp, recipient, reason, "campaignId", "rewardToken", CAST(claimed AS text) as claimed
-        FROM "ClaimsOverTime"
-        WHERE
-            "chainId" IN (${Prisma.join(chainIds)}) AND
-            "recipient"=${user}
-        ) as cc
-     LEFT JOIN "Tokens" as t
-     ON cc."chainId"=t."chainId" AND cc."rewardToken"=t.address
-     ORDER BY cc.timestamp ASC
-    `;
-export const CLAIMS_FOR_USER_GROUPED = (chainIds, user) => Prisma.sql `
-    SELECT cc."chainId", cc.timestamp, cc.recipient, cc."campaignId", cc."rewardToken" as token, t.symbol, t.decimals, cc.claimed FROM (
-        SELECT "chainId", timestamp, recipient, "campaignId", "rewardToken", CAST(SUM(CAST(claimed as numeric)) as text) as claimed
-        FROM "ClaimsOverTime"
-        WHERE
-            "chainId" IN (${Prisma.join(chainIds)}) AND
-            "recipient"=${user}
-        GROUP BY timestamp, recipient, "chainId", "rewardToken", "campaignId"
-        ) as cc
-     LEFT JOIN "Tokens" as t
-     ON cc."chainId"=t."chainId" AND cc."rewardToken"=t.address
-     ORDER BY cc.timestamp ASC
-    `;

package/dist/src/utils/queries/endingCampaigns.d.ts

@@ -1,10 +0,0 @@
-import { Prisma } from "../../../database/engine/.generated";
-export type EndingCampaigns = {
-    chainId: number;
-    creator: string;
-    symbol: string;
-    amount: number;
-    endTimestamp: number;
-};
-export declare const ENDING_CAMPAIGNS: (maxEndDate: number, minStartDate: number, minEndDate: number) => Prisma.Sql;
-export declare const NON_RENEWED_CAMPAIGNS: (maxEndDate: number, minStartDate: number, minEndDate: number) => Prisma.Sql;

package/dist/src/utils/queries/endingCampaigns.js

@@ -1,21 +0,0 @@
-import { Prisma } from "../../../database/engine/.generated";
-export const ENDING_CAMPAIGNS = (maxEndDate, minStartDate, minEndDate) => Prisma.sql `
-    SELECT c."chainId", c.creator, t.symbol, CAST(c.amount as numeric) / 10^t.decimals as amount, c."endTimestamp" FROM (
-        SELECT * FROM "Campaigns" WHERE "endTimestamp"<=${maxEndDate}
-        AND "startTimestamp">=${minStartDate} AND "endTimestamp">=${minEndDate}
-    ) as c
-    INNER JOIN "Tokens" as t
-    ON c."chainId"=t."chainId" AND c."rewardToken"=t.address
-    `;
-export const NON_RENEWED_CAMPAIGNS = (maxEndDate, minStartDate, minEndDate) => Prisma.sql `
-    SELECT c."chainId", c.creator, t.symbol, CAST(c.amount as numeric) / 10^t.decimals as amount, c."endTimestamp", c."mainParameter", cf."campaignId" FROM (
-        SELECT * FROM "Campaigns" WHERE "endTimestamp"<=${maxEndDate}
-        AND "startTimestamp">=${minStartDate} AND "endTimestamp">=${minEndDate}
-    ) as c
-    LEFT JOIN (
-        SELECT DISTINCT ON (c."chainId", c."mainParameter", c."rewardToken") * FROM "Campaigns" as c WHERE c."endTimestamp">${maxEndDate}
-    ) as cf
-    ON c."chainId"=cf."chainId" AND c."mainParameter"=cf."mainParameter" AND c."rewardToken"=cf."rewardToken"
-    INNER JOIN "Tokens" as t
-    ON c."chainId"=t."chainId" AND c."rewardToken"=t.address
-`;

package/dist/src/utils/queries/futureCampaigns.d.ts

@@ -1,3 +0,0 @@
-import { Prisma } from "../../../database/engine/.generated";
-export declare const FUTURE_CAMPAIGNS_FOR_CHAIN: (chainId: number, now: number) => Prisma.Sql;
-export declare const FUTURE_CAMPAIGNS: (now: number) => Prisma.Sql;

package/dist/src/utils/queries/futureCampaigns.js

@@ -1,19 +0,0 @@
-import { Prisma } from "../../../database/engine/.generated";
-export const FUTURE_CAMPAIGNS_FOR_CHAIN = (chainId, now) => Prisma.sql `
-    SELECT
-        *
-    FROM "Campaigns"
-    WHERE
-        "chainId" = ${chainId} AND
-        "startTimestamp" >= ${now} AND
-        "campaignType" != 0
-        
-    `;
-export const FUTURE_CAMPAIGNS = (now) => Prisma.sql `
-    SELECT
-        *
-    FROM "Campaigns"
-    WHERE
-        "startTimestamp" >= ${now} AND
-        "campaignType" != 0
-    `;

package/dist/src/utils/queries/mainParameterCampaigns.d.ts

@@ -1,5 +0,0 @@
-import { Prisma } from "../../../database/engine/.generated";
-export type CampaignsForMainParameterQueryOutput = {
-    campaignId: string;
-}[];
-export declare const CAMPAIGNS_FOR_MAIN_PARAMETER: (chainId: number, mainParameter: string) => Prisma.Sql;