@merkl/api 0.21.46 → 1.0.0

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

@@ -1,102 +0,0 @@
-import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
-import { log } from "@/utils/logger";
-import { engineDbClient } from "@db";
-import { ChainInteractionService, DistributionCreatorInterface, registry } from "@sdk";
-import { UserRepository } from "./user.repository";
-// ─── Users Services ──────────────────────────────────────────────────────────
-export class UserService {
-    static async findUnique(address) {
-        return await UserRepository.findUnique(address);
-    }
-    static async findUniqueOrThrow(address) {
-        return await UserRepository.findUniqueOrThrow(address);
-    }
-    static async findMany(query) {
-        return await UserRepository.findMany(query);
-    }
-    static async findManyWithTags() {
-        return await UserRepository.findManyWithTags();
-    }
-    static async create(user) {
-        return await UserRepository.create(user);
-    }
-    static async createMany(users) {
-        return await UserRepository.createMany(users);
-    }
-    static async updateTags(user, tags) {
-        if (!(await UserRepository.findUnique(user))) {
-            await UserRepository.create({ address: user, tags: [] });
-        }
-        return await UserRepository.updateTags(user, tags);
-    }
-    static async checkTerms(userAddress, chainId) {
-        const distributorAddress = registry(chainId)?.Merkl?.DistributionCreator;
-        if (!distributorAddress)
-            throw new Error(`Distributor address not found for chainId ${chainId}`);
-        const calls = [
-            {
-                callData: DistributionCreatorInterface.encodeFunctionData("userSignatureWhitelist", [userAddress]),
-                target: distributorAddress,
-                allowFailure: false,
-            },
-            {
-                callData: DistributionCreatorInterface.encodeFunctionData("userSignatures", [userAddress]),
-                target: distributorAddress,
-                allowFailure: false,
-            },
-            {
-                callData: DistributionCreatorInterface.encodeFunctionData("messageHash"),
-                target: distributorAddress,
-                allowFailure: false,
-            },
-        ];
-        const decoders = (r) => [
-            DistributionCreatorInterface.decodeFunctionResult("userSignatureWhitelist", r[0].returnData)[0].toString(),
-            DistributionCreatorInterface.decodeFunctionResult("userSignatures", r[1].returnData)[0].toString(),
-            DistributionCreatorInterface.decodeFunctionResult("messageHash", r[2].returnData)[0].toString(),
-        ];
-        const result = await ChainInteractionService(chainId).fetchAndDecodeMultiple(calls, decoders);
-        const [signatureWhitelist, userSignature, messageHash] = result;
-        const hasNotSigned = signatureWhitelist === "0" && userSignature !== messageHash;
-        return !hasNotSigned;
-    }
-    static async syncTags() {
-        // 1 - engine -> api db
-        const creatorTags = await engineDbClient.campaignCreators.findMany();
-        log.info(`syncing ${creatorTags.length} creator tags`);
-        await UserRepository.createMany(creatorTags.map(tag => {
-            return {
-                address: tag.address,
-                tags: [],
-            };
-        }));
-        for (const tag of creatorTags) {
-            await UserRepository.updateTags(tag.address, tag.tags.split(",").map(tag => tag.trim()));
-        }
-        // 2 - api -> engine db
-        const apiUsers = await UserRepository.findManyWithTags();
-        for (const tag of creatorTags) {
-            if (creatorTags.findIndex(t => t.address === tag.address) === -1) {
-                await engineDbClient.campaignCreators.create({
-                    data: {
-                        address: tag.address,
-                        tags: apiUsers.find(u => u.address === tag.address)?.tags.join(",") || "",
-                    },
-                });
-            }
-        }
-    }
-    static async syncOpportunityTags() {
-        const users = await UserRepository.findManyWithTags();
-        for (const user of users) {
-            const opportunities = await OpportunityService.findMany({ creatorAddress: user.address });
-            for (const opportunity of opportunities) {
-                if (!user.tags.every(tag => opportunity.tags.includes(tag))) {
-                    log.local(`updating tags for opportunity ${opportunity.id}: adding ${user.tags.join(",")}`);
-                    log.local(`opportunity tags: ${opportunity.tags.join(",")}`);
-                    await OpportunityService.update(opportunity.id, { tags: [...opportunity.tags, ...user.tags] });
-                }
-            }
-        }
-    }
-}

package/dist/src/plugins/error-handling.plugin.js

@@ -1,34 +0,0 @@
-import { BadRequestError, ConflictError, HttpError, NotFoundError, UnauthorizedError } from "@/errors";
-import { log } from "@/utils/logger";
-// ─── Error Handler Plugin ────────────────────────────────────────────────────
-export const ErrorHandler = (app) => app
-    // ─── Error Types ─────────────────────────────────────────────────────
-    .error({
-    HttpError,
-    BadRequestError,
-    ConflictError,
-    NotFoundError,
-    UnauthorizedError,
-})
-    // ─── Error Handling ──────────────────────────────────────────────────
-    .onError(({ code, error, set }) => {
-    set.headers["content-type"] = "application/json";
-    if (code === "HttpError") {
-        log.error("HttpError", error);
-        set.status = error.httpCode;
-        return {
-            name: error.name,
-            message: error.message,
-            info: error.info,
-        };
-    }
-    if (code === "VALIDATION") {
-        return {
-            name: "ValidationError",
-            message: JSON.parse(error.message).summary,
-            info: JSON.parse(error.message),
-        };
-    }
-    log.error("Unknown error", error);
-    return error;
-});

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

@@ -1,115 +0,0 @@
-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, ETH_ADDRESS, 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 === ETH_ADDRESS ||
-            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("/allowances", 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

@@ -1,25 +0,0 @@
-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("/balances", 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

@@ -1,9 +0,0 @@
-import { PriceService } from "@/modules/v4/price/price.service";
-import { t } from "elysia";
-export const response = t.Array(t.Object({ rate: t.Number(), token: t.String() }));
-export default (app) => app.get("/prices", async () => {
-    return await PriceService.findManyArray();
-}, {
-    query: t.Object({}),
-    tags: ["Onchain"],
-});

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

@@ -1,6 +0,0 @@
-import Elysia from "elysia";
-import allowances from "./allowances";
-import balances from "./balances";
-import prices from "./prices";
-import tokens from "./tokens";
-export const v1 = new Elysia({ tags: ["v1"], prefix: "/v1" }).use(allowances).use(balances).use(prices).use(tokens);

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

@@ -1,17 +0,0 @@
-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("/tokens", async () => {
-    return await getTokensListWithCache();
-}, {
-    query: t.Object({}),
-    tags: ["Onchain"],
-});

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

@@ -1,13 +0,0 @@
-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("/merkl", merklRoute, { query, tags: ["Merkl"] });

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

@@ -1,3 +0,0 @@
-import Elysia from "elysia";
-import merkl from "./merkl";
-export const v2 = new Elysia({ tags: ["v2"], prefix: "/v2" }).use(merkl);

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

@@ -1,43 +0,0 @@
-import { getTokensListWithCache } from "@/libs/getTokensList";
-import { TTLPresets } from "@/modules/v4/cache/cache.model";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { Pricer } from "@/utils/pricer";
-import { t } from "elysia";
-/**
- * @deprecated - can be removed once old apps are not in used anymore
- */
-export const response = t.Array(t.Object({ rate: t.Number(), token: t.String() }));
-export default (app) => app.get("/app", async () => {
-    return await CacheService.wrap(TTLPresets.MIN_5, async () => {
-        const json = {
-            tokens: await getTokensListWithCache(),
-            prices: await (await Pricer.load()).getArray(),
-        };
-        try {
-            const v3Tokens = await TokenService.findMany({ items: 0 });
-            for (const token of v3Tokens) {
-                if (!json.tokens[token.chainId]) {
-                    json.tokens[token.chainId] = {};
-                }
-                if (!json.tokens[token.chainId][token.address] && token.icon?.length > 0) {
-                    json.tokens[token.chainId][token.address] = {
-                        address: token.address,
-                        chainId: token.chainId,
-                        decimals: token.decimals,
-                        name: token.name,
-                        symbol: token.symbol,
-                        logoURI: token.icon,
-                    };
-                }
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-        return json;
-    });
-}, {
-    query: t.Object({}),
-    tags: ["Onchain"],
-});

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

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

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

@@ -1,81 +0,0 @@
-import { Redis } from "@/cache";
-import { staticCampaignWithCache } from "@/libs/staticCampaigns";
-import { engineDbClient } from "@db";
-import { ChainId, isSupportedChain } from "@sdk";
-import { t } from "elysia";
-import moment from "moment";
-/**
- * @deprecated - to remove in favor of new status page
- */
-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

@@ -1,29 +0,0 @@
-import checkQueryChainIdValidity from "@/hooks/checkQueryChainIdValidity";
-import { engineDbClient } from "@db";
-import { Prisma } from "@db/engine";
-import { t } from "elysia";
-/**
- * @deprecated
- * This whole file is deprecated but is still used by Pancakeswap to populate their db so we can't remove it yet.
- */
-export const query = t.Object({
-    campaignId: t.String(),
-    chainId: t.Numeric(),
-    byReason: t.Optional(t.BooleanString()),
-});
-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 default (app) => app.use(checkQueryChainIdValidity()).get("/campaignClaims", async ({ query }) => {
-    const campaignId = query.campaignId;
-    const chainId = query.chainId;
-    return await engineDbClient.$queryRaw(CLAIMS_OVER_TIME(chainId, campaignId));
-}, {
-    query,
-    tags: ["Campaigns"],
-});

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

@@ -1,28 +0,0 @@
-import { RewardService } from "@/modules/v4/reward/reward.service";
-import { t } from "elysia";
-import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
-/**
- * @deprecated - conversion to v4 done
- */
-export const query = t.Object({
-    campaignIds: t.String(),
-    chainId: t.Numeric(),
-});
-export default (app) => app.use(checkQueryChainIdValidity()).get("/campaignUnclaimed", async ({ query }) => {
-    const campaignIds = query.campaignIds;
-    let campaigns = [];
-    if (campaignIds.includes(",")) {
-        campaigns = campaignIds.split(",");
-    }
-    else {
-        campaigns = [campaignIds];
-    }
-    const chainId = query.chainId;
-    return await RewardService.getUnclaimed({
-        chainId,
-        campaignIds: campaigns,
-    });
-}, {
-    query,
-    tags: ["Campaigns"],
-});