@merkl/api 0.21.46 → 1.0.0

package/dist/src/routes/v3/twt/participants.js

@@ -1,63 +0,0 @@
-import { Redis } from "@/cache";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { log } from "@/utils/logger";
-import { Interface } from "@ethersproject/abi";
-import { BN2Number, ChainId, ERC20Interface } from "@sdk";
-import { t } from "elysia";
-const stTwtABI = [
-    {
-        constant: true,
-        inputs: [],
-        name: "participantNumber",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const stTwtAddresses = {
-    [ChainId.BSC]: "0x5029f49585D57ed770D2194841B5A0bE06BFc2ED",
-};
-const stTwtInterface = new Interface(stTwtABI);
-async function getTwtParticipants(chainId) {
-    const tokenAddress = stTwtAddresses[chainId];
-    const calls = [
-        {
-            allowFailure: true,
-            callData: stTwtInterface.encodeFunctionData("participantNumber", []),
-            target: tokenAddress,
-        },
-        {
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("totalSupply"),
-            target: tokenAddress,
-        },
-    ];
-    const result = await batchMulticallCallWithRetry(chainId, { calls });
-    const res = {
-        participants: 0,
-        totalSupply: 0,
-    };
-    try {
-        res.participants = stTwtInterface.decodeFunctionResult("participantNumber", result[0].returnData)[0].toNumber();
-        res.totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[1].returnData)[0], 18);
-    }
-    catch (_error) {
-        log.local(`❌ Failed to call participantNumber for ${tokenAddress} on ${chainId}`);
-    }
-    return res;
-}
-export const query = t.Object({
-    chainId: t.Numeric(),
-});
-export default (app) => app.get("", async ({ query }) => {
-    const chainId = query.chainId;
-    return await Redis.getOrSet(`TwtParticipants_${chainId}`, getTwtParticipants, chainId);
-}, {
-    query,
-});

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

@@ -1,29 +0,0 @@
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { ChainUniqueDto } from "@/modules/v4/chain/chain.model";
-import { Bytes32Dto, UniV4ChainIdArray, } from "@/modules/v4/uniswap/uniswap.model";
-import { UniswapService } from "@/modules/v4/uniswap/uniswap.service";
-import { UnsupportedNetwork } from "@/utils/error";
-export default (app) => app.group("/uniswapv4", router => router
-    .get("/", async () => {
-    return await CacheService.get(UniswapService.getUniswapV4Pools, []);
-}, {
-    tags: ["uniswapv4"],
-})
-    .get("/:chainId", async ({ params }) => {
-    return (await CacheService.get(UniswapService.getUniswapV4Pools, []))?.[params.chainId];
-}, {
-    params: ChainUniqueDto,
-    beforeHandle: ({ params }) => {
-        if (!UniV4ChainIdArray.includes(params.chainId))
-            throw new UnsupportedNetwork(params.chainId);
-    },
-    tags: ["uniswapv4"],
-})
-    .get("/pool/:poolId", async ({ params }) => {
-    return Object.values((await CacheService.get(UniswapService.getUniswapV4Pools, [])))
-        .flatMap(x => (x ? Object.values(x) : []))
-        .filter(p => p.poolId === params.poolId);
-}, {
-    params: Bytes32Dto,
-    tags: ["uniswapv4"],
-}));

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

@@ -1,47 +0,0 @@
-import { Redis } from "@/cache";
-import { staticCampaignWithCache } from "@/libs/staticCampaigns";
-import { ChainId, HOUR, isSupportedChain } from "@sdk";
-import { t } from "elysia";
-export const query = t.Object({});
-export const response = t.Record(t.String({ title: "ChainId" }), t.Record(t.String({ title: "CampaignId" }), t.Number()));
-export default (app) => app.get("/updates", computeUpdatesWithCache, {
-    query,
-    response: {
-        400: t.Object({
-            error: t.String(),
-            message: t.Optional(t.String()),
-        }),
-    },
-    tags: ["Campaigns"],
-});
-const computeUpdates = async () => {
-    const chainIds = Object.keys(ChainId)
-        .map(k => Number.parseInt(k))
-        .filter(k => isSupportedChain(k, "merkl"));
-    const res = {};
-    const cacheData = await Redis.getManyWithArgs("MerklChainData", chainIds);
-    const lastUpdatesByChain = {};
-    chainIds.forEach((chainId, index) => {
-        if (!cacheData[index])
-            return;
-        lastUpdatesByChain[chainId] = cacheData[index].endOfDisputePeriod - 2 * HOUR;
-    });
-    const now = Math.floor(Date.now() / 1000);
-    for (const chainId of chainIds) {
-        if (!res[chainId])
-            res[chainId] = {};
-        const campaigns = await staticCampaignWithCache(chainId);
-        for (const campaign of campaigns) {
-            const campaignId = campaign.campaignId;
-            if (campaign.startTimestamp <= now && now <= campaign.endTimestamp) {
-                res[chainId][campaignId] =
-                    lastUpdatesByChain?.[campaign?.chainId] ?? lastUpdatesByChain[chainId] ?? campaign.startTimestamp;
-            }
-            else if (now > campaign.endTimestamp) {
-                res[chainId][campaignId] = campaign.endTimestamp;
-            }
-        }
-    }
-    return res;
-};
-const computeUpdatesWithCache = async () => await Redis.getOrSet("Updates", computeUpdates);

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

@@ -1,63 +0,0 @@
-import checkQueryAddressValidity from "@/hooks/checkQueryAddressValidity";
-import { RewardConvertorService } from "@/modules/v4/reward/reward.converter";
-import { UserRewardV3Dto } from "@/modules/v4/reward/reward.model";
-import { RewardService } from "@/modules/v4/reward/reward.service";
-import { InvalidParameter } from "@/utils/error";
-import { throwOnUnsupportedChainId } from "@/utils/throw";
-import { t } from "elysia";
-import { utils } from "ethers";
-import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
-/**
- * @deprecated - conversion to v4 done
- */
-export const query = t.Object({
-    chainId: t.Number(),
-    reloadChainId: t.Optional(t.Number()),
-    mainParameter: t.Optional(t.String()),
-    proof: t.Optional(t.String()),
-    rewardToken: t.Optional(t.String()),
-    user: t.String(),
-});
-export default (app) => app
-    .use(checkQueryChainIdValidity())
-    .use(checkQueryAddressValidity())
-    .get("/userRewards", async ({ query }) => {
-    const { chainId, user } = query;
-    throwOnUnsupportedChainId(chainId);
-    let proofString = query.proof;
-    let proof = false;
-    if (proofString) {
-        proofString = proofString.toLowerCase();
-        if (proofString !== "true" && proofString !== "false") {
-            throw new InvalidParameter(`Invalid proof parameter: ${proofString} is not a boolean`);
-        }
-        if (proofString === "true") {
-            proof = true;
-        }
-    }
-    let mainParameter = query.mainParameter;
-    if (mainParameter) {
-        try {
-            mainParameter = utils.getAddress(mainParameter);
-        }
-        catch (_e) {
-            throw new InvalidParameter(`Invalid main parameter: ${mainParameter} is not an address`);
-        }
-        if (proof) {
-            throw new InvalidParameter("Cannot request proof and mainParameter at the same time");
-        }
-    }
-    // @Warning: this is not taking into account the mainParameter filter
-    const v4Res = await RewardService.getUserRewardsByChain(user, false, [chainId], query.reloadChainId ?? null, true);
-    const v3Res = RewardConvertorService.convertV4toUserRewardV3(v4Res, proof);
-    return v3Res;
-}, {
-    transform({ query }) {
-        if (query.chainId !== undefined) {
-            query.chainId = Number.parseInt(query.chainId);
-        }
-    },
-    query,
-    response: { 200: UserRewardV3Dto },
-    tags: ["Rewards"],
-});

package/dist/src/scripts/fill-coingecko-data.js

@@ -1,3 +0,0 @@
-import { CoingeckoService } from "@/modules/v4/coingecko/coingecko.service";
-await CoingeckoService.fillTokensWithCoingeckoData();
-process.exit(0);

package/dist/src/scripts/fill-descriptions.js

@@ -1,101 +0,0 @@
-import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
-import { apiDbClient } from "@db";
-let page = 0;
-while (true) {
-    const opportunities = await apiDbClient.opportunity.findMany({
-        select: {
-            id: true,
-            name: true,
-            explorerAddress: true,
-            depositUrl: true,
-            identifier: true,
-            MainProtocol: {
-                select: {
-                    url: true,
-                    name: true,
-                },
-            },
-            Chain: {
-                select: {
-                    name: true,
-                },
-            },
-            type: true,
-            action: true,
-            Tokens: {
-                select: {
-                    symbol: true,
-                    address: true,
-                    name: true,
-                },
-            },
-            Campaigns: {
-                take: 1,
-                include: {
-                    RewardToken: {
-                        select: {
-                            address: true,
-                        },
-                    },
-                },
-            },
-            description: true,
-        },
-        take: 1000,
-        skip: page * 1000,
-    });
-    page += 1;
-    if (opportunities.length === 0) {
-        break;
-    }
-    for (const opportunity of opportunities) {
-        const { action, Tokens: tokens, MainProtocol: protocol, Chain: chain } = opportunity;
-        const symbols = tokens?.map(t => t.symbol).join("-");
-        let description = "";
-        switch (action) {
-            case "POOL":
-                description = `Earn rewards by providing liquidity to the ${protocol?.name} ${symbols} pool on ${chain.name}, or through a liquidity manager supported by Merkl`;
-                break;
-            case "HOLD":
-                description = `Earn rewards by holding ${symbols} or by staking it in a supported contract`;
-                break;
-            case "LEND":
-                description = `Earn rewards by lending ${symbols} to ${protocol?.name} on ${chain.name}`;
-                break;
-            case "BORROW":
-                description = `Earn rewards by taking a long position on ${protocol?.name} ${symbols} on ${chain.name}`;
-                break;
-            case "DROP":
-                description = `Visit your dashboard to check if you've earned rewards from this airdrop`;
-                break;
-            case "LONG":
-                description = `Borrow ${symbols} on ${protocol?.name} on ${chain.name}`;
-                break;
-            case "SHORT":
-                description = `Earn rewards by taking a short position on ${protocol?.name} ${symbols} on ${chain.name}`;
-                break;
-            case "SWAP":
-                description = `Earn rewards by trading ${symbols} on ${chain.name}`;
-                break;
-            default:
-                break;
-        }
-        const howToSteps = OpportunityService.howToSteps(action, tokens, protocol);
-        if (description !== opportunity.description) {
-            await apiDbClient.opportunity.update({
-                where: {
-                    id: opportunity.id,
-                },
-                data: {
-                    description,
-                    howToSteps,
-                },
-            });
-            console.log(`updated description for ${opportunity.id} - ${opportunity.name} to ${description}`);
-        }
-        else {
-            console.log(`no description for ${opportunity.id} - ${opportunity.name}`);
-        }
-    }
-}
-process.exit(0);

package/dist/src/scripts/fill-unknown-tokens.js

@@ -1,58 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { apiDbClient } from "@db";
-const tokens = await apiDbClient.token.findMany({
-    select: {
-        address: true,
-        chainId: true,
-        name: true,
-        symbol: true,
-    },
-    where: {
-        symbol: "UNKNOWN",
-    },
-    orderBy: {
-        id: "asc",
-    },
-});
-log.info(`found ${tokens.length} tokens with UNKNOWN symbol`);
-for (const token of tokens) {
-    try {
-        const onchainData = await TokenService.fetchOnChain({
-            chainId: token.chainId,
-            address: token.address,
-        });
-        if (onchainData.name !== token.name) {
-            await apiDbClient.token.update({
-                where: {
-                    chainId_address: {
-                        address: token.address,
-                        chainId: token.chainId,
-                    },
-                },
-                data: {
-                    name: onchainData.name,
-                },
-            });
-            log.info(`updated name for ${token.address} on ${token.chainId} from ${token.name} to ${onchainData.name}`);
-        }
-        if (onchainData.symbol !== token.symbol) {
-            await apiDbClient.token.update({
-                where: {
-                    chainId_address: {
-                        address: token.address,
-                        chainId: token.chainId,
-                    },
-                },
-                data: {
-                    symbol: onchainData.symbol,
-                },
-            });
-            log.info(`updated name for ${token.address} on ${token.chainId} from ${token.name} to ${onchainData.name}`);
-        }
-    }
-    catch (e) {
-        console.error(e);
-    }
-}
-process.exit(0);

package/dist/src/scripts/reparse-opportunities.js

@@ -1,75 +0,0 @@
-// One-off script to modify opportunity metadata
-import { metadataBuilderFactory } from "@/engine/metadata/factory";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { log } from "@/utils/logger";
-import { apiDbClient } from "@db";
-import { Campaign as CampaignType } from "@sdk";
-const opportunities = await apiDbClient.opportunity.findMany({
-    select: {
-        id: true,
-        name: true,
-        explorerAddress: true,
-        depositUrl: true,
-        identifier: true,
-        MainProtocol: {
-            select: {
-                url: true,
-            },
-        },
-        type: true,
-        Campaigns: {
-            take: 1,
-            include: {
-                RewardToken: {
-                    select: {
-                        address: true,
-                    },
-                },
-            },
-        },
-    },
-    where: {
-        status: "PAST",
-        id: {
-            gt: "8105750301162585090",
-        },
-    },
-    orderBy: {
-        id: "asc",
-    },
-});
-for (const opportunity of opportunities) {
-    try {
-        const campaign = CampaignService.format(await CampaignService.findUniqueOrThrow(opportunity.Campaigns[0].id));
-        const metadata = await metadataBuilderFactory(CampaignType[opportunity.type]).build(campaign, opportunity.identifier);
-        if (!!metadata?.explorerAddress && !opportunity.explorerAddress) {
-            await apiDbClient.opportunity.update({
-                where: {
-                    id: opportunity.id,
-                },
-                data: {
-                    explorerAddress: metadata.explorerAddress,
-                },
-            });
-            log.info(`updated explorerAdd for ${opportunity.id} - ${opportunity.name} to ${metadata.explorerAddress}`);
-        }
-        if (!!metadata?.depositUrl &&
-            (!opportunity.depositUrl ||
-                (opportunity.depositUrl === opportunity?.MainProtocol?.url &&
-                    metadata.depositUrl !== opportunity?.MainProtocol?.url))) {
-            await apiDbClient.opportunity.update({
-                where: {
-                    id: opportunity.id,
-                },
-                data: {
-                    depositUrl: metadata.depositUrl,
-                },
-            });
-            log.info(`updated depositUrl for ${opportunity.id} - ${opportunity.name} from ${opportunity.depositUrl} to ${metadata.depositUrl}`);
-        }
-    }
-    catch (e) {
-        console.error(e);
-    }
-}
-process.exit(0);

package/dist/src/types/external/spectraAPI.js

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

package/dist/src/types/index.js

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

package/dist/src/utils/TailSampler.js

@@ -1,23 +0,0 @@
-import { ParentBasedSampler, SamplingDecision, TraceIdRatioBasedSampler, } from "@opentelemetry/sdk-trace-node";
-export class TailSampler {
-    baseSampler;
-    constructor(ratio) {
-        this.baseSampler = new ParentBasedSampler({
-            root: new TraceIdRatioBasedSampler(ratio),
-        });
-    }
-    shouldSample(context, traceId, spanName, spanKind, attributes, links) {
-        const result = this.baseSampler.shouldSample(context, traceId, spanName, spanKind, attributes, links);
-        // Override sampling decision if error detected
-        if (attributes["error"] || Number(attributes["http.status_code"]) >= 500) {
-            return {
-                decision: SamplingDecision.RECORD_AND_SAMPLED,
-                attributes: { error_sampled: "true" },
-            };
-        }
-        return result;
-    }
-    toString() {
-        return "CustomTailSampler";
-    }
-}

package/dist/src/utils/bigintToString.js

@@ -1,20 +0,0 @@
-// opportunities[0].campaigns[0]
-// opportunities: map bigintToString
-// campaign: map bigintToString
-export default function bigintToString(obj) {
-    if (Array.isArray(obj))
-        return obj.map(bigintToString);
-    if (typeof obj === "object" && obj !== null) {
-        return Object.keys(obj).reduce((acc, key) => {
-            const value = obj[key];
-            if (typeof value === "bigint")
-                acc[key] = value.toString();
-            else if (typeof value === "object" || Array.isArray(value))
-                acc[key] = bigintToString(value);
-            else
-                acc[key] = value;
-            return acc;
-        }, {});
-    }
-    return obj;
-}

package/dist/src/utils/caseChanges.js

@@ -1,15 +0,0 @@
-export function camelToKebabCase(str) {
-    return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-}
-export function kebabToCamelCase(str) {
-    return str.replace(/-./g, match => match[1].toUpperCase());
-}
-export function kebabToPascalCase(str) {
-    return str
-        .split("-")
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-        .join("");
-}
-export function capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}