@merkl/api 0.10.129 → 0.10.130

package/dist/src/plugins/logger.plugin.js

@@ -0,0 +1,22 @@
+// ─── Logger Plugin ───────────────────────────────────────────────────────────
+import Elysia from "elysia";
+export const Logger = new Elysia().onRequest(async ({ request }) => {
+    const globalLogFields = {
+        httpRequest: request.method,
+    };
+    if (typeof request !== "undefined") {
+        const traceHeader = request.headers.get("X-Cloud-Trace-Context");
+        if (traceHeader && process.env.PROJECT_ID) {
+            const [trace] = traceHeader.split("/");
+            globalLogFields["logging.googleapis.com/trace"] = `projects/${process.env.PROJECT_ID}/traces/${trace}`;
+        }
+    }
+    const entry = Object.assign({
+        severity: "NOTICE",
+        // message: "This is the default display field.",
+        // Log viewer accesses 'component' as 'jsonPayload.component'.
+        component: request.url.split("/")[4],
+    }, globalLogFields);
+    // Serialize to a JSON string and output.
+    console.log(JSON.stringify(entry));
+});

package/dist/src/routes/v1/allowances.js

@@ -0,0 +1,115 @@
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { getUserBalances } from "../../libs/tokens/balances";
+import { executeSimple } from "../../utils/execute";
+import { throwOnInvalidAddress } from "../../utils/throw";
+import { ChainId, ERC20Interface, registry } from "@sdk";
+import { t } from "elysia";
+export async function getUserAllowances(user, spenders, tokens, chainId, additionalTokenAddresses) {
+    /** Filtered tokens list */
+    const filteredTokens = Object.keys(tokens).reduce((filteredTokensList, tokenAddress) => {
+        if (tokenAddress === "0x0000000000000000000000000000000000001010" ||
+            tokenAddress === "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE" ||
+            tokenAddress === registry(ChainId.MAINNET)?.veANGLE)
+            return filteredTokensList;
+        if (!tokens[tokenAddress]?.wrappingMethod || tokens[tokenAddress]?.wrappingMethod !== "Convex") {
+            filteredTokensList[tokenAddress] = tokens[tokenAddress];
+        }
+        return filteredTokensList;
+    }, {});
+    const calls = [];
+    for (const tokenAddress of Object.keys(filteredTokens)) {
+        for (const spender of spenders) {
+            calls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("allowance", [user, spender]),
+                target: tokenAddress,
+            });
+        }
+    }
+    if (!!additionalTokenAddresses && additionalTokenAddresses?.length > 0) {
+        for (const tokenAddress of additionalTokenAddresses) {
+            for (const spender of spenders) {
+                calls.push({
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("allowance", [user, spender]),
+                    target: tokenAddress,
+                });
+            }
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const res = {};
+                let j = 0;
+                for (const tokenAddress of Object.keys(filteredTokens)) {
+                    const auxRes = {};
+                    for (const spender of spenders) {
+                        let allowance = "0";
+                        try {
+                            allowance = ERC20Interface.decodeFunctionResult("allowance", result[j])[0]?.toString();
+                        }
+                        catch (error) {
+                            console.log(`❌ Failed to call allowance for ${tokenAddress} on ${chainId}`);
+                        }
+                        auxRes[spender] = {
+                            allowance: allowance,
+                        };
+                        j++;
+                    }
+                    res[tokenAddress] = {
+                        ...auxRes,
+                        decimals: filteredTokens[tokenAddress]?.decimals,
+                    };
+                }
+                if (!!additionalTokenAddresses && additionalTokenAddresses?.length > 0) {
+                    for (const tokenAddress of additionalTokenAddresses) {
+                        const auxRes = {};
+                        for (const spender of spenders) {
+                            let allowance = "0";
+                            try {
+                                allowance = ERC20Interface.decodeFunctionResult("allowance", result[j])[0]?.toString();
+                            }
+                            catch (error) {
+                                console.log(`❌ Failed to call allowance for ${tokenAddress} on ${chainId}`);
+                            }
+                            auxRes[spender] = {
+                                allowance: allowance,
+                            };
+                            j++;
+                        }
+                        res[tokenAddress] = {
+                            ...auxRes,
+                            decimals: filteredTokens[tokenAddress]?.decimals,
+                        };
+                    }
+                }
+                return res;
+            },
+        },
+    };
+}
+export const query = t.Object({
+    additionalTokenAddresses: t.Optional(t.Array(t.String())),
+    chainId: t.Numeric(),
+    user: t.String(),
+});
+export const response = t.Record(t.String({ title: "TokenAddress" }), t.Object({ balance: t.Numeric(), decimals: t.Number(), symbol: t.String() }));
+export default (app) => app
+    .use(checkQueryChainIdValidity())
+    .use(checkQueryAddressValidity())
+    .get("", async ({ query }) => {
+    const { chainId, user } = query;
+    const additionalTokenAddresses = query.additionalTokenAddresses;
+    additionalTokenAddresses?.forEach(tokenAddress => throwOnInvalidAddress(tokenAddress));
+    return !!additionalTokenAddresses?.length && additionalTokenAddresses?.length > 0
+        ? await executeSimple(chainId, getUserBalances(user, chainId, additionalTokenAddresses))
+        : await executeSimple(chainId, getUserBalances(user, chainId));
+}, {
+    query,
+    tags: ["Onchain"],
+});

package/dist/src/routes/v1/balances.js

@@ -0,0 +1,25 @@
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { getUserBalances } from "../../libs/tokens/balances";
+import { executeSimple } from "../../utils/execute";
+import { throwOnInvalidAddress } from "../../utils/throw";
+import { t } from "elysia";
+export const response = t.Record(t.String({ title: "TokenAddress" }), t.Object({ balance: t.Numeric(), decimals: t.Number(), symbol: t.String() }));
+export default (app) => app
+    .use(checkQueryChainIdValidity())
+    .use(checkQueryAddressValidity())
+    .get("", async ({ query }) => {
+    const { chainId, user } = query;
+    const additionalTokenAddresses = query.additionalTokenAddresses;
+    additionalTokenAddresses?.forEach(tokenAddress => throwOnInvalidAddress(tokenAddress));
+    return !!additionalTokenAddresses?.length && additionalTokenAddresses?.length > 0
+        ? await executeSimple(chainId, getUserBalances(user, chainId, additionalTokenAddresses))
+        : await executeSimple(chainId, getUserBalances(user, chainId));
+}, {
+    query: t.Object({
+        additionalTokenAddresses: t.Optional(t.Array(t.String())),
+        chainId: t.Numeric(),
+        user: t.String(),
+    }),
+    tags: ["Onchain"],
+});

package/dist/src/routes/v1/prices.js

@@ -0,0 +1,11 @@
+import { Pricer } from "../../utils/pricer";
+import { t } from "elysia";
+export const response = t.Array(t.Object({ rate: t.Number(), token: t.String() }));
+export default (app) => app.get("", async () => {
+    return await Pricer.load().then(async (pricer) => {
+        return pricer.getArray();
+    });
+}, {
+    query: t.Object({}),
+    tags: ["Onchain"],
+});

package/dist/src/routes/v1/tokens.js

@@ -0,0 +1,17 @@
+import { getTokensListWithCache } from "../../libs/getTokensList";
+import { t } from "elysia";
+export const response = t.Record(t.String({ title: "ChainId" }), t.Record(t.String({ title: "TokenAddress" }), t.Object({
+    address: t.String(),
+    name: t.String(),
+    decimals: t.Number(),
+    symbol: t.String(),
+    hasPermit: t.Boolean(),
+    useInSwap: t.Optional(t.Boolean()),
+    logoURI: t.String(),
+})));
+export default (app) => app.get("", async () => {
+    return await getTokensListWithCache();
+}, {
+    query: t.Object({}),
+    tags: ["Onchain"],
+});

package/dist/src/routes/v2/merkl.js

@@ -0,0 +1,13 @@
+import { t } from "elysia";
+import { merklRoute } from "../v3/merkl";
+export const query = t.Object({
+    AMMs: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    "AMMs[0]": t.Optional(t.String()),
+    "AMMs[]": t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    chainIds: t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric())])),
+    "chainIds[0]": t.Optional(t.Numeric()),
+    "chainIds[]": t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric())])),
+    user: t.Optional(t.String()),
+    onlyLive: t.Optional(t.String()),
+});
+export default (app) => app.get("", merklRoute, { query, tags: ["Merkl"] });

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

@@ -0,0 +1,63 @@
+import { Redis } from "../../cache";
+import param from "../../types/parameters";
+import { ANGLE_NETWORKS, Campaign, ChainId, isSupportedChain, registry, } from "@sdk";
+import { t } from "elysia";
+import { UnsupportedNetwork } from "../../utils/error";
+export const query = t.Object({
+    chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    types: t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric()), t.String(), t.Array(t.String())])),
+    live: t.Optional(t.BooleanString()),
+    creatorTag: t.Optional(t.String()),
+});
+export const response = t.Record(t.Union(ANGLE_NETWORKS.merkl.map(chain => t.Literal(`${chain}`))), t.Optional(t.Record(t.String({ title: "id" }), t.Record(t.String({ title: "CampaignId" }), t.Object({
+    chainId: param.Chain.type,
+    campaignId: t.String(),
+    tags: t.Optional(t.Array(t.String())),
+    creator: t.String(),
+    rewardToken: t.String(),
+    mainParameter: t.String(),
+    campaignParameters: t.Object({}),
+    campaignType: param.Type.type,
+})))));
+export default (app) => app.get("", async ({ query, set }) => {
+    const rawChainIds = query.chainIds;
+    let chainIds;
+    if (!rawChainIds) {
+        chainIds = Object.keys(ChainId)
+            .map(k => Number.parseInt(k))
+            .filter(k => isSupportedChain(k, "merkl"));
+    }
+    else if (typeof rawChainIds === "string") {
+        chainIds = [Number.parseInt(rawChainIds)];
+    }
+    else {
+        chainIds = rawChainIds.map(chainId => Number.parseInt(chainId));
+    }
+    for (const chainId of chainIds) {
+        if (!!chainId &&
+            (!isSupportedChain(chainId, "merkl") ||
+                !registry(chainId)?.Merkl?.DistributionCreator ||
+                !registry(chainId)?.Merkl?.Distributor ||
+                !registry(chainId)?.Merkl?.CoreMerkl)) {
+            throw new UnsupportedNetwork(chainId);
+        }
+    }
+    const cacheKeys = chainIds.map(chainId => `Campaigns_${chainId}`);
+    const dynamicData = (await Redis.getMany(cacheKeys)).reduce((prev, chainData, index) => {
+        if (!!chainData) {
+            prev[chainIds[index]] = Object.keys(chainData).reduce((prev, curr) => {
+                if (Number.parseInt(curr.split("_")[0]) === Campaign.ERC20) {
+                    prev[curr] = chainData[curr];
+                }
+                return prev;
+            }, {});
+        }
+        return prev;
+    }, {});
+    return dynamicData;
+}, {
+    query: t.Object({
+        chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    }),
+    tags: ["Campaigns"],
+});

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

@@ -0,0 +1,18 @@
+import { getTokensListWithCache } from "../../libs/getTokensList";
+import { Pricer } from "../../utils/pricer";
+import { t } from "elysia";
+export const response = t.Array(t.Object({ rate: t.Number(), token: t.String() }));
+export default (app) => app.get("", async () => {
+    const json = {};
+    const tokensPromise = getTokensListWithCache().then(r => {
+        json.tokens = r;
+    });
+    const promisePrices = Pricer.load().then(async (pricer) => {
+        json.prices = pricer.getArray();
+    });
+    await Promise.all([promisePrices, tokensPromise]);
+    return json;
+}, {
+    query: t.Object({}),
+    tags: ["Onchain"],
+});

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

@@ -0,0 +1,18 @@
+import { BlacklistService } from "../../modules/v4/blacklist";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+export const query = t.Object({
+    user: t.String(),
+});
+export const response = t.Object({
+    isBlacklisted: t.Boolean(),
+});
+export default (app) => app.use(checkQueryAddressValidity()).get("", async ({ query }) => {
+    return { isBlacklisted: await BlacklistService.isBlacklisted(query.user) };
+}, {
+    query,
+    response: {
+        200: response,
+    },
+    tags: ["Merkl"],
+});

package/dist/src/routes/v3/campaign/delay.js

@@ -0,0 +1,78 @@
+import { Redis } from "../../../cache";
+import { staticCampaignWithCache } from "../../../libs/staticCampaigns";
+import { engineDbClient } from "../../../utils/prisma";
+import { ChainId, isSupportedChain } from "@sdk";
+import { t } from "elysia";
+import moment from "moment";
+export const query = t.Object({
+    onlyLive: t.Optional(t.Boolean()),
+});
+export const response = t.Record(t.String({ title: "ChainId" }), t.Record(t.String({ title: "CampaignId" }), t.Number()));
+export default (app) => app.get("", async ({ query }) => {
+    return await computeDelayWithCache(!!query.onlyLive);
+}, {
+    transform({ query }) {
+        if (!query.onlyLive)
+            query.onlyLive = true;
+        else
+            query.onlyLive = query.onlyLive === "true"; // To Patch uncorrect Elysia types (Elysia provide boolean instead of string from queryParams)!
+    },
+    query,
+    response: {
+        400: t.Object({
+            error: t.String(),
+            message: t.Optional(t.String()),
+        }),
+    },
+    tags: ["Campaigns"],
+});
+const computeDelay = async (onlyLive) => {
+    const chainIds = Object.keys(ChainId)
+        .map(k => Number.parseInt(k))
+        .filter(k => isSupportedChain(k, "merkl"));
+    const res = {};
+    const timeNow = moment().unix();
+    const cacheData = await Redis.getManyWithArgs("MerklChainData", chainIds);
+    const lastUpdateTimestampList = await engineDbClient.leaves.groupBy({
+        _max: {
+            lastProcessedTimestamp: true,
+        },
+        where: {
+            chainId: {
+                in: chainIds,
+            },
+            root: { in: cacheData.map(data => data?.merkleRoot).filter(r => !!r) },
+        },
+        by: ["chainId", "campaignId"],
+    });
+    const lastObjectTimestampObject = lastUpdateTimestampList.reduce((acc, { chainId, campaignId, _max }) => {
+        if (_max.lastProcessedTimestamp) {
+            acc[chainId] = acc[chainId] || {};
+            acc[chainId][campaignId] = _max.lastProcessedTimestamp;
+        }
+        return acc;
+    }, {});
+    // Iterate through each chainId and its associated campaigns
+    for (const chainId of chainIds) {
+        const campaigns = await staticCampaignWithCache(chainId);
+        for (const campaign of campaigns) {
+            const { campaignId, startTimestamp, endTimestamp, campaignType, mainParameter } = campaign;
+            // Skip non-live campaigns if onlyLive is true
+            if (onlyLive && (startTimestamp > timeNow || endTimestamp < timeNow))
+                continue;
+            const lastProcessedTimestamp = lastObjectTimestampObject[chainId]?.[campaignId] || 0;
+            res[chainId] = res[chainId] || {};
+            const delay = Math.min(endTimestamp, timeNow) - Math.max(lastProcessedTimestamp, startTimestamp);
+            res[chainId][campaignId] = {
+                lastProcessedTimestamp,
+                startTimestamp,
+                endTimestamp,
+                delay,
+                campaignType,
+                mainParameter,
+            };
+        }
+    }
+    return res;
+};
+const computeDelayWithCache = async (onlyLive) => await Redis.getOrSet("Delays", computeDelay, onlyLive);

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

@@ -0,0 +1,24 @@
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { engineDbClient } from "../../utils/prisma";
+import { CLAIMS_OVER_TIME, CLAIMS_OVER_TIME_GROUPED } from "../../utils/queries/claimsOverTime";
+import { t } from "elysia";
+export const query = t.Object({
+    campaignId: t.String(),
+    chainId: t.Numeric(),
+    byReason: t.Optional(t.BooleanString()),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
+    const campaignId = query.campaignId;
+    const chainId = query.chainId;
+    let byReason = true;
+    if (query.byReason !== undefined) {
+        byReason = query.byReason;
+    }
+    if (!byReason) {
+        return await engineDbClient.$queryRaw(CLAIMS_OVER_TIME_GROUPED(chainId, campaignId));
+    }
+    return await engineDbClient.$queryRaw(CLAIMS_OVER_TIME(chainId, campaignId));
+}, {
+    query,
+    tags: ["Campaigns"],
+});

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

@@ -0,0 +1,22 @@
+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("", 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/campaignUnclaimed.js

@@ -0,0 +1,28 @@
+import { engineDbClient } from "../../utils/prisma";
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { UNCLAIMED_FOR_CAMPAIGNS } from "../../utils/queries/unclaimed";
+export const query = t.Object({
+    campaignIds: t.String(),
+    chainId: t.Numeric(),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
+    const campaignIds = query.campaignIds;
+    let campaigns = [];
+    if (campaignIds.includes(",")) {
+        campaigns = campaignIds.split(",");
+    }
+    else {
+        campaigns = [campaignIds];
+    }
+    const chainId = query.chainId;
+    const unclaimed = await engineDbClient.$queryRaw(UNCLAIMED_FOR_CAMPAIGNS(chainId, campaigns));
+    const res = {};
+    for (const row of unclaimed) {
+        res[row.campaignId] = BigInt(row.unclaimed).toString();
+    }
+    return res;
+}, {
+    query,
+    tags: ["Campaigns"],
+});

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

@@ -0,0 +1,101 @@
+import { Redis } from "../../cache";
+import { removeTestTokens } from "../../entities/campaign";
+import param from "../../types/parameters";
+import { ANGLE_NETWORKS, ChainId, isSupportedChain, registry, } from "@sdk";
+import { t } from "elysia";
+import { UnsupportedNetwork } from "../../utils/error";
+export const query = t.Object({
+    chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    types: t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric()), t.String(), t.Array(t.String())])),
+    live: t.Optional(t.BooleanString()),
+    creatorTag: t.Optional(t.String()),
+    hideTestTokens: t.Optional(t.String()),
+});
+export const response = t.Record(t.Union(ANGLE_NETWORKS.merkl.map(chain => t.Literal(`${chain}`))), t.Optional(t.Record(t.String({ title: "id" }), t.Record(t.String({ title: "CampaignId" }), t.Object({
+    chainId: param.Chain.type,
+    campaignId: t.String(),
+    tags: t.Optional(t.Array(t.String())),
+    creator: t.String(),
+    rewardToken: t.String(),
+    mainParameter: t.String(),
+    campaignParameters: t.Object({}),
+    campaignType: param.Type.type,
+})))));
+export default (app) => app.get("", async ({ query }) => {
+    let hideTestTokens = false;
+    if (typeof query.hideTestTokens === "string" && query.hideTestTokens === "true") {
+        hideTestTokens = true;
+    }
+    let rawChainIds = query.chainIds;
+    if (typeof rawChainIds === "string" && rawChainIds.includes(",")) {
+        rawChainIds = rawChainIds.split(",");
+    }
+    let chainIds;
+    if (!rawChainIds) {
+        chainIds = Object.keys(ChainId)
+            .map(k => Number.parseInt(k))
+            .filter(k => isSupportedChain(k, "merkl"));
+    }
+    else if (typeof rawChainIds === "string") {
+        chainIds = [Number.parseInt(rawChainIds)];
+    }
+    else {
+        chainIds = rawChainIds.map(chainId => Number.parseInt(chainId));
+    }
+    const rawTypes = query.types;
+    let types = [];
+    if (!rawTypes) {
+    }
+    else if (Number.parseInt(rawTypes.toString()).toString() === rawTypes.toString()) {
+        types = [Number.parseInt(rawTypes.toString())];
+    }
+    else {
+        types = rawTypes.map(type => Number.parseInt(type.toString()));
+    }
+    for (const chainId of chainIds) {
+        if (!!chainId &&
+            (!isSupportedChain(chainId, "merkl") ||
+                !registry(chainId)?.Merkl?.DistributionCreator ||
+                !registry(chainId)?.Merkl?.Distributor ||
+                !registry(chainId)?.Merkl?.CoreMerkl)) {
+            throw new UnsupportedNetwork(chainId);
+        }
+    }
+    const campaignCachePrefix = query.live === true ? "LiveCampaigns" : "Campaigns";
+    const dynamicData = (await Redis.getManyWithArgs(campaignCachePrefix, chainIds)).reduce((prev, allData, index) => {
+        if (!!allData) {
+            prev[chainIds[index]] = Object.keys(allData).reduce((acc, curr) => {
+                if ((types.length === 0 || types.includes(Number.parseInt(curr.split("_")[0]))) &&
+                    (!hideTestTokens || removeTestTokens(allData[curr]))) {
+                    acc[curr] = allData[curr];
+                }
+                return acc;
+            }, {});
+        }
+        return prev;
+    }, {});
+    // Remove everything that doesn't contain the creator tag
+    if (!!query.creatorTag) {
+        for (const c of Object.keys(dynamicData)) {
+            for (const type_mainParam of Object.keys(dynamicData[c])) {
+                for (const campaignId of Object.keys(dynamicData[c][type_mainParam])) {
+                    if (!dynamicData[c][type_mainParam][campaignId]?.tags?.includes(query.creatorTag)) {
+                        delete dynamicData[c][type_mainParam][campaignId];
+                    }
+                }
+                // Delete the type_mainParam if it's empty
+                if (Object.keys(dynamicData[c][type_mainParam]).length === 0) {
+                    delete dynamicData[c][type_mainParam];
+                }
+            }
+            // Delete the c if it's empty
+            if (Object.keys(dynamicData[c]).length === 0) {
+                delete dynamicData[c];
+            }
+        }
+    }
+    return dynamicData;
+}, {
+    query,
+    tags: ["Campaigns"],
+});

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

@@ -0,0 +1,19 @@
+import { engineDbClient } from "../../utils/prisma";
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { OpportunityNotFound } from "../../utils/error";
+import { CAMPAIGNS_BY_MAIN_PARAMETER } from "../../utils/queries/campaignsForMainParameter";
+export const query = t.Object({
+    chainId: t.Numeric(),
+    mainParameter: t.String(),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
+    const chainId = query.chainId;
+    const campaigns = await engineDbClient.$queryRaw(CAMPAIGNS_BY_MAIN_PARAMETER(chainId, query.mainParameter));
+    if (!campaigns)
+        throw new OpportunityNotFound(query.mainParameter, chainId);
+    return campaigns;
+}, {
+    query,
+    tags: ["Campaigns"],
+});

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

@@ -0,0 +1,54 @@
+import { Redis } from "../../cache";
+import { engineDbClient } from "../../utils/prisma";
+import { t } from "elysia";
+export default (app) => app.post("", 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"],
+});