@merkl/api 0.10.129 → 0.10.130

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

@@ -0,0 +1,73 @@
+import param from "../../types/parameters";
+import { ANGLE_NETWORKS } from "@sdk";
+import { withTimeout } from "@sdk";
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { merklChainDataWithCache } from "../../libs/merklChainData";
+import { log } from "../../utils/logger";
+export const query = t.Object({
+    chainId: t.Optional(param.Chain.type),
+});
+export const response = t.Object({
+    disputes: t.Record(t.String({ title: "ChainId" }), t.Object({
+        disputeLive: t.Boolean(),
+        endOfDisputePeriod: t.Number(),
+        root: t.String(),
+        treeRoot: t.String(),
+        lastTreeRoot: t.String(),
+    })),
+    rewardTokens: t.Record(t.String({ title: "ChainId" }), t.Array(t.Union([
+        t.Object({
+            decimals: t.Number(),
+            minimumAmountPerEpoch: t.Number(),
+            symbol: t.String(),
+            token: t.String(),
+        }),
+        t.Object({
+            decimals: t.Number(),
+            minimumAmountPerEpoch: t.Number(),
+            isTokenWrapper: t.String(),
+            token: t.String(),
+        }),
+    ]))),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
+    const chainId = query.chainId;
+    const result = {
+        disputes: {},
+        rewardTokens: {},
+    };
+    const promises = [];
+    const chainsToInspect = chainId ? [chainId] : ANGLE_NETWORKS.merkl;
+    for (const chain of chainsToInspect) {
+        promises.push(withTimeout(merklChainDataWithCache(chain), 5000));
+    }
+    const merklChainDataPromises = await Promise.allSettled(promises);
+    for (let i = 0; i < merklChainDataPromises.length; i++) {
+        const merklChainDataPromise = merklChainDataPromises[i];
+        if (merklChainDataPromise.status === "rejected") {
+            continue;
+        }
+        const merklChainData = merklChainDataPromise.value;
+        if (!!merklChainData && !!merklChainData?.validRewardTokens) {
+            result.disputes[chainsToInspect[i]] = {
+                disputeLive: merklChainData.disputeLive,
+                endOfDisputePeriod: merklChainData.endOfDisputePeriod ?? 0,
+                root: merklChainData.merkleRoot,
+                treeRoot: merklChainData.treeRoot,
+                lastTreeRoot: merklChainData.lastTreeRoot,
+            };
+            result.rewardTokens[chainsToInspect[i]] = merklChainData.validRewardTokens;
+        }
+        else {
+            log.local(`Failed to get validRewardTokens for chain ${chainsToInspect[i]}`);
+        }
+    }
+    return result;
+}, {
+    transform({ query }) {
+        query.chainId = !query.chainId ? undefined : Number.parseInt(query.chainId);
+    },
+    query,
+    tags: ["Merkl"],
+});

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

@@ -0,0 +1,23 @@
+import { parseCampaign } from "@sdk";
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+export const query = t.Object({
+    campaign: t.Any(),
+    chainId: t.Numeric(),
+    index: t.Optional(t.Numeric()),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async (request) => {
+    const chainId = request.query.chainId;
+    try {
+        const parsingResult = await parseCampaign(chainId, await JSON.parse(request.query.campaign), request.query.index ?? 0);
+        if (parsingResult.success)
+            return JSON.stringify(parsingResult.parsedCampaign);
+        throw parsingResult.message;
+    }
+    catch (e) {
+        return { message: `Error parsing campaign: ${e}`, name: "Error" };
+    }
+}, {
+    query,
+    tags: ["Campaigns"],
+});

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

@@ -0,0 +1,40 @@
+import { BASE_9, Campaign, buildCampaignPayload, parseCampaign } from "@sdk";
+import { t } from "elysia";
+import { BigNumber } from "ethers";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { computeFee } from "../../libs/computeFee";
+export const query = t.Object({
+    chainId: t.Numeric(),
+    config: t.String(),
+    signature: t.Optional(t.Any()),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async (request) => {
+    const chainId = request.query.chainId;
+    // TODO cleaner type enforcing and conversion
+    const parsedConfig = JSON.parse(request.query.config);
+    if (!!parsedConfig.url) {
+        if (!parsedConfig.url.startsWith("http")) {
+            parsedConfig.url = Buffer.from(parsedConfig.url, "base64").toString("utf-8");
+        }
+    }
+    const feePromise = computeFee(chainId, parsedConfig);
+    /** In the json case the amount given is "post-fees" */
+    let fee;
+    if (parsedConfig.campaignType === Campaign.JSON_AIRDROP) {
+        fee = (await feePromise).fee;
+        parsedConfig.amount = BigNumber.from(parsedConfig.amount)?.mul(BASE_9)?.div(BASE_9.sub(fee)).add(1).toString();
+    }
+    const { args, payload } = buildCampaignPayload(parsedConfig, chainId, request.query.signature);
+    const parsingResult = await parseCampaign(chainId, args, 0);
+    if (!parsingResult.success) {
+        return { message: parsingResult.message, name: "Error" };
+    }
+    /** In other cases we can compute the fee only now */
+    if (parsedConfig.campaignType !== Campaign.JSON_AIRDROP) {
+        fee = (await feePromise).fee;
+    }
+    return { args, parsedCampaign: parsingResult.parsedCampaign, payload, fee };
+}, {
+    query,
+    tags: ["Campaigns"],
+});

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

@@ -0,0 +1,88 @@
+import { AMM, BN2Number, FactoryAddress, IzumiPool__factory, UniswapV3Pool__factory } from "@sdk";
+import { t } from "elysia";
+import { ethers, utils } from "ethers";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { log } from "../../utils/logger";
+import { providers } from "../../utils/providers";
+const fetchPoolData = async (poolAddress, chainId) => {
+    const result = {};
+    const poolContract = UniswapV3Pool__factory.connect(poolAddress.toLowerCase(), providers[chainId]);
+    const izumiContract = IzumiPool__factory.connect(poolAddress.toLowerCase(), providers[chainId]);
+    try {
+        let poolName = "";
+        const factory = await poolContract.factory();
+        let found = false;
+        for (const amm in AMM) {
+            // enums store both name and index as keys, we are only interesed by the names one
+            if (!Number.isNaN(Number(amm)))
+                continue;
+            const sdkFactoryAddress = FactoryAddress[chainId][AMM[amm]];
+            if (!!sdkFactoryAddress &&
+                utils.getAddress(factory.toLowerCase()) === utils.getAddress(sdkFactoryAddress.toLowerCase())) {
+                found = true;
+                result.amm = AMM[amm];
+                poolName += `${amm} - `;
+                break;
+            }
+        }
+        if (!found)
+            return result;
+        try {
+            const token0 = await poolContract.token0();
+            result.token0 = token0;
+            const tokenContract = new ethers.Contract(token0, ["function symbol() external view returns(string)"], providers[chainId]);
+            poolName += await tokenContract.symbol();
+        }
+        catch (error) {
+            try {
+                const token0 = await izumiContract.tokenX();
+                result.token0 = token0;
+                const tokenContract = new ethers.Contract(token0, ["function symbol() external view returns(string)"], providers[chainId]);
+                poolName += await tokenContract.symbol();
+            }
+            catch {
+                log.error(`❌ cannot fetch token0 data for ${poolName}`, error);
+            }
+        }
+        try {
+            const token1 = await poolContract.token1();
+            result.token1 = token1;
+            const tokenContract = new ethers.Contract(token1, ["function symbol() external view returns(string)"], providers[chainId]);
+            poolName += `/${await tokenContract.symbol()}`;
+        }
+        catch (error) {
+            try {
+                const token1 = await izumiContract.tokenY();
+                result.token1 = token1;
+                const tokenContract = new ethers.Contract(token1, ["function symbol() external view returns(string)"], providers[chainId]);
+                poolName += await tokenContract.symbol();
+            }
+            catch {
+                log.error(`❌ cannot fetch token1 data for ${poolName}`, error);
+            }
+        }
+        try {
+            const fee = await poolContract.fee();
+            result.fee = BN2Number(fee, 4);
+            poolName += `-${BN2Number(fee, 4)}%`;
+        }
+        catch (error) {
+            log.error(`cannot fetch fee for ${poolName}`, error);
+        }
+        result.name = poolName;
+    }
+    catch (e) {
+        log.error("fetchUniswapV3PoolData failed", e);
+    }
+    return result;
+};
+export const query = t.Object({
+    chainId: t.Numeric(),
+    poolAddress: t.String(),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
+    return await fetchPoolData(query.poolAddress, query.chainId);
+}, {
+    query,
+    tags: ["Protocols"],
+});

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

@@ -0,0 +1,62 @@
+import { Redis } from "../../cache";
+import param from "../../types/parameters";
+import { Campaign } from "@sdk";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { getUserPositionsV2 } from "../../libs/positions";
+import { prepareFetch } from "../../libs/positions/prepareFetch";
+export const query = t.Object({
+    chainId: param.Chain.type,
+    user: t.String(),
+});
+const positions = {
+    [Campaign.CLAMM]: t.Object({
+        almAddress: t.Optional(t.String()),
+        id: t.String(),
+        origin: t.Number(),
+        inRangeLiquidity: t.Number(),
+        lowerTick: t.Number(),
+        upperTick: t.Number(),
+        totalLiquidity: t.Number(),
+        tvl: t.Number(),
+        balance0: t.Number(),
+        balance1: t.Number(),
+    }),
+    [Campaign.SILO]: t.Object({
+        origin: t.String(),
+        totalSupply: t.Number(),
+        tvl: t.Number(),
+        balance: t.Number(),
+    }),
+};
+export const response = t.Record(t.TemplateLiteral([param.Type.type, t.Literal("_"), t.String()]), t.Object({
+    userPositions: t.Array(t.Union(Object.values(positions))),
+}));
+export default (app) => app
+    .use(checkQueryAddressValidity())
+    .use(checkQueryChainIdValidity())
+    .get("", async ({ query }) => {
+    const user = query.user;
+    const chainId = query.chainId;
+    // Check that chainId is a valid MerklChainId
+    const allOpportunities = await Redis.get("LiveCampaigns", chainId);
+    if (!allOpportunities) {
+        return {};
+    }
+    const positionsToCheck = {}; // TODO: add typing (depends on campaign type)
+    for (const campaigns of Object.values(allOpportunities)) {
+        for (const campaign of Object.values(campaigns)) {
+            const type = campaign.campaignType;
+            // Allows to have only one call getting campaign data
+            positionsToCheck[type] = prepareFetch(type, positionsToCheck[type] ? positionsToCheck[type] : {}, campaign);
+        }
+    }
+    return await getUserPositionsV2(positionsToCheck, chainId, user);
+}, {
+    transform({ query }) {
+        query.chainId = !query.chainId ? undefined : Number.parseInt(query.chainId);
+    },
+    query,
+    tags: ["Merkl"],
+});

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

@@ -0,0 +1,26 @@
+import { getRadiantMarketsWithCache } from "../../libs/parse/marketsWithCache";
+import { t } from "elysia";
+export const query = t.Object({
+    poolAddressProvider: t.String(),
+    chainId: t.Numeric(),
+});
+export const response = t.Array(t.Object({
+    asset: t.String(),
+    symbol: t.String(),
+    aToken: t.Optional(t.String()),
+    stableDebtToken: t.Optional(t.String()),
+    variableDebtToken: t.Optional(t.String()),
+    aTokenSymbol: t.Optional(t.String()),
+    aTokenName: t.Optional(t.String()),
+    vdTokenSymbol: t.Optional(t.String()),
+    vdTokenName: t.Optional(t.String()),
+    vault: t.Optional(t.String()),
+    vaultSymbol: t.Optional(t.String()),
+}));
+export default (app) => app.get("", async (request) => {
+    const chainId = request.query.chainId;
+    return await getRadiantMarketsWithCache(chainId, request.query.poolAddressProvider);
+}, {
+    query,
+    tags: ["Protocols"],
+});

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

@@ -0,0 +1,20 @@
+import { getCampaignRewardsWithCache } from "../../libs/reports/campaignReport";
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { merklChainDataWithCache } from "../../libs/merklChainData";
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
+    const campaignId = query.campaignId;
+    const chainId = query.chainId;
+    const root = (await merklChainDataWithCache(chainId)).merkleRoot;
+    let recipients = [];
+    if (!!root) {
+        recipients = await getCampaignRewardsWithCache(chainId, root, campaignId);
+    }
+    return recipients;
+}, {
+    query: t.Object({
+        campaignId: t.String(),
+        chainId: t.Numeric(),
+    }),
+    tags: ["Campaigns"],
+});

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

@@ -0,0 +1,33 @@
+import { RewardService } from "../../modules/v4/reward";
+import { RewardConvertorService } from "../../modules/v4/reward/rewardConvertor.service";
+import { ChainId, isSupportedChain } from "@sdk";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+export const query = t.Object({
+    chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    user: t.String(),
+    creatorTag: t.Optional(t.String()),
+});
+export default (app) => app.use(checkQueryAddressValidity()).get("", async ({ query }) => {
+    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 user = query.user;
+    // @Warning: this is not taking into account the creator tag filter
+    const v4Res = await RewardService.getUserRewardsByChain(user, false, chainIds);
+    const v3Res = RewardConvertorService.convertV4toRewardV3(v4Res);
+    return v3Res;
+}, { query, tags: ["Rewards"] });

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

@@ -0,0 +1,51 @@
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { merklChainDataWithCache } from "../../libs/merklChainData";
+import { getCampaignRewardsDeltaWithCache, getCampaignRewardsWithCache } from "../../libs/reports/campaignReport";
+import { getRewardsMainParameterDeltaWithCache, getRewardsMainParameterWithCache, } from "../../libs/reports/mainParameterRewards";
+import { InvalidParameter } from "../../utils/error";
+export const query = t.Object({
+    campaignId: t.Optional(t.String()),
+    chainId: t.Numeric(),
+    from: t.Optional(t.Numeric()),
+    mainParameter: t.Optional(t.String()),
+    to: t.Optional(t.Numeric()),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query, set }) => {
+    const mainParameter = query.mainParameter;
+    const campaignId = query.campaignId;
+    const chainId = query.chainId;
+    const from = query.from;
+    const to = query.to;
+    if ((!!to && !from) || (!to && !!from))
+        throw new InvalidParameter("API for Merkl products by Angle Labs requires both from and to timestamps when to timestamp is provided");
+    if (!!campaignId && !!mainParameter)
+        throw new InvalidParameter("API for Merkl products by Angle Labs requires either a campaignId or a mainParameter, not both");
+    if (!campaignId && !mainParameter)
+        throw new InvalidParameter("API for Merkl products by Angle Labs requires either a campaignId or a mainParameter");
+    if (!to && !from) {
+        // Get the latest root and return the current rewards state
+        const currentRoot = (await merklChainDataWithCache(chainId)).merkleRoot;
+        if (!currentRoot) {
+            return [];
+        }
+        if (!!campaignId) {
+            return await getCampaignRewardsWithCache(chainId, currentRoot, campaignId);
+        }
+        if (!!mainParameter) {
+            return await getRewardsMainParameterWithCache(chainId, currentRoot, mainParameter);
+        }
+    }
+    if (!!to && !!from) {
+        if (!!campaignId) {
+            return await getCampaignRewardsDeltaWithCache(chainId, from, to, campaignId);
+        }
+        if (!!mainParameter) {
+            return await getRewardsMainParameterDeltaWithCache(chainId, from, to, mainParameter);
+        }
+    }
+    return [];
+}, {
+    query,
+    tags: ["Rewards"],
+});

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

@@ -0,0 +1,47 @@
+import param from "../../types/parameters";
+import { engineDbClient } from "../../utils/prisma";
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+export const query = t.Object({
+    chainId: t.Numeric(),
+    timestamp: t.Numeric(),
+});
+export const response = t.Object({
+    chainId: param.Chain.type,
+    epoch: t.Number(),
+    root: t.String(),
+    timestamp: t.Number(),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
+    const chainId = query.chainId;
+    // Query all campaigns
+    let root = await engineDbClient.merklRoots.findFirst({
+        orderBy: {
+            timestamp: "desc",
+        },
+        where: {
+            chainId: chainId,
+            timestamp: {
+                lte: query.timestamp,
+            },
+        },
+    });
+    if (!root) {
+        // Find the root with the lowest timestamp
+        root = await engineDbClient.merklRoots.findFirst({
+            orderBy: {
+                timestamp: "asc",
+            },
+            where: {
+                chainId: chainId,
+            },
+        });
+    }
+    return root;
+}, {
+    transform({ query }) {
+        query.chainId = !query.chainId ? undefined : Number.parseInt(query.chainId);
+    },
+    query,
+    tags: ["Merkl"],
+});

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

@@ -0,0 +1,20 @@
+import { getSiloMarketsWithCache } from "../../libs/parse/marketsWithCache";
+import { t } from "elysia";
+export const query = t.Object({
+    repository: t.String(),
+    chainId: t.Numeric(),
+});
+export const response = t.Array(t.Object({
+    asset: t.String(),
+    assetSymbol: t.String(),
+    silo: t.String(),
+    version: t.Number(),
+    assets: t.Array(t.Object({ address: t.String(), symbol: t.String() })),
+}));
+export default (app) => app.get("", async (request) => {
+    const chainId = request.query.chainId;
+    return await getSiloMarketsWithCache(chainId, request.query.repository);
+}, {
+    query,
+    tags: ["Protocols"],
+});

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

@@ -0,0 +1,24 @@
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { getTokenInfo } from "../../libs/tokens/tokenInfo";
+import { executeSimple } from "../../utils/execute";
+import { t } from "elysia";
+export const query = t.Object({
+    chainId: t.Numeric(),
+    address: t.String(),
+});
+export const response = t.Object({
+    name: t.String(),
+    symbol: t.String(),
+    decimals: t.Number(),
+});
+export default (app) => app
+    .use(checkQueryChainIdValidity())
+    .use(checkQueryAddressValidity("address"))
+    .get("", async ({ query: { address, chainId } }) => {
+    return await executeSimple(chainId, getTokenInfo(address));
+}, {
+    query,
+    response: { 200: response },
+    tags: ["Onchain"],
+});

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

@@ -0,0 +1,24 @@
+// 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("", 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/routes/v3/twt/participants.js

@@ -0,0 +1,11 @@
+import { t } from "elysia";
+import { getTwtParticipantsWithCache } from "../../../libs/custom/twtParticipants";
+export const query = t.Object({
+    chainId: t.Numeric(),
+});
+export default (app) => app.get("", async ({ query, set }) => {
+    const chainId = query.chainId;
+    return await getTwtParticipantsWithCache(chainId);
+}, {
+    query,
+});

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

@@ -0,0 +1,47 @@
+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("", 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

@@ -0,0 +1,59 @@
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import { RewardService, UserRewardV3Dto } from "../../modules/v4/reward";
+import { RewardConvertorService } from "../../modules/v4/reward/rewardConvertor.service";
+import param from "../../types/parameters";
+import { InvalidParameter } from "../../utils/error";
+import { throwOnUnsupportedChainId } from "../../utils/throw";
+import { t } from "elysia";
+import { utils } from "ethers";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+export const query = t.Object({
+    chainId: param.Chain.type,
+    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("", 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]);
+    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/types/index.js

@@ -0,0 +1,6 @@
+export var Campaign;
+(function (Campaign) {
+    Campaign[Campaign["INVALID"] = 0] = "INVALID";
+    Campaign[Campaign["ERC20"] = 1] = "ERC20";
+    Campaign[Campaign["CLAMM"] = 2] = "CLAMM";
+})(Campaign || (Campaign = {}));