@merkl/api 0.9.15

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

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

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

@@ -0,0 +1,70 @@
+// @ts-nocheck
+import { Redis } from "@/cache";
+import { ChainId, isSupportedChain } from "@sdk";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import { getUserPositionsV2 } from "../../libs/positions";
+import { prepareFetch } from "../../libs/positions/prepareFetch";
+import { throwOnUnsupportedChainId } from "../../utils/throw";
+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("/multiChainPositions", async ({ query, set }) => {
+    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));
+    }
+    for (const chainId of chainIds)
+        throwOnUnsupportedChainId(chainId);
+    const user = query.user;
+    for (const chainId of chainIds)
+        throwOnUnsupportedChainId(chainId);
+    const cacheKeys = chainIds.map(chainId => `LiveCampaigns_${chainId}`);
+    const cacheData = await Redis.findMany(cacheKeys);
+    const promises = [];
+    let i = 0;
+    for (const chainId of chainIds) {
+        if (!cacheData[i]) {
+            promises.push(getUserPositionsV2({}, chainId, user));
+            i++;
+            continue;
+        }
+        const allOpportunities = cacheData[i];
+        const positionsToCheck = {};
+        for (const campaigns of Object.values(allOpportunities)) {
+            for (const campaign of Object.values(campaigns)) {
+                if (campaign.tags.includes(query.creatorTag)) {
+                    const type = campaign.campaignType;
+                    positionsToCheck[type] = prepareFetch(type, positionsToCheck[type] ? positionsToCheck[type] : {}, campaign);
+                }
+            }
+        }
+        promises.push(getUserPositionsV2(positionsToCheck, chainId, user));
+        i++;
+    }
+    const result = await Promise.all(promises);
+    i = 0;
+    const finalResult = {};
+    for (const chainId of chainIds) {
+        finalResult[chainId] = result[i];
+        i++;
+    }
+    return finalResult;
+}, {
+    query,
+    tags: ["Protocols"],
+});

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

@@ -0,0 +1,52 @@
+import type Elysia from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    campaigns: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    testTokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    mainParameter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    action: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    opportunity: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                type?: number | undefined;
+                tag?: string | undefined;
+                action?: string | undefined;
+                chainId?: number | undefined;
+                campaigns?: boolean | undefined;
+                mainParameter?: string | undefined;
+                testTokens?: boolean | undefined;
+            };
+            headers: unknown;
+            response: {
+                200: {};
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,28 @@
+import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
+import { t } from "elysia";
+export const query = t.Object({
+    campaigns: t.Optional(t.Boolean()),
+    testTokens: t.Optional(t.Boolean()),
+    mainParameter: t.Optional(t.String()),
+    chainId: t.Optional(t.Numeric()),
+    type: t.Optional(t.Numeric()),
+    action: t.Optional(t.String()),
+    tag: t.Optional(t.String()),
+});
+export default (app) => {
+    return app.get("/opportunity", async ({ query: { campaigns: showCampaigns, ...filters } }) => {
+        await OpportunityConvertorService.logKeyAndTTLV3Opportunities(showCampaigns ?? false, !!filters.testTokens ? filters.testTokens : false, !!filters.mainParameter ? filters.mainParameter : undefined, !!filters.chainId ? filters.chainId.toString() : undefined);
+        return await OpportunityConvertorService.wrapV3Opportunities(showCampaigns ?? false, !!filters.testTokens ? filters.testTokens : false, !!filters.mainParameter ? filters.mainParameter : undefined, !!filters.chainId ? filters.chainId.toString() : undefined);
+    }, {
+        transform({ query }) {
+            query.chainId = !query.chainId ? undefined : Number.parseInt(query.chainId.toString());
+            query.type = !query.type ? undefined : Number.parseInt(query.type.toString());
+            query.campaigns =
+                query.campaigns === false || query.campaigns?.toString() === "false" ? false : !!query.campaigns;
+            query.testTokens =
+                query.testTokens === false || query.testTokens?.toString() === "false" ? false : !!query.testTokens;
+        },
+        query,
+        tags: ["Opportunity"],
+    });
+};

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

@@ -0,0 +1,78 @@
+import { type Elysia } from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const response: import("@sinclair/typebox").TObject<{
+    disputes: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        disputeLive: import("@sinclair/typebox").TBoolean;
+        endOfDisputePeriod: import("@sinclair/typebox").TNumber;
+        root: import("@sinclair/typebox").TString;
+        treeRoot: import("@sinclair/typebox").TString;
+        lastTreeRoot: import("@sinclair/typebox").TString;
+    }>>;
+    rewardTokens: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        decimals: import("@sinclair/typebox").TNumber;
+        minimumAmountPerEpoch: import("@sinclair/typebox").TNumber;
+        symbol: import("@sinclair/typebox").TString;
+        token: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        decimals: import("@sinclair/typebox").TNumber;
+        minimumAmountPerEpoch: import("@sinclair/typebox").TNumber;
+        isTokenWrapper: import("@sinclair/typebox").TString;
+        token: import("@sinclair/typebox").TString;
+    }>]>>>;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    overview: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                chainId?: number | undefined;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    disputes: {
+                        [chainId: number]: {
+                            root: string;
+                            endOfDisputePeriod: number;
+                            disputeLive: boolean;
+                            treeRoot: string;
+                            lastTreeRoot: string;
+                        };
+                    };
+                    rewardTokens: {
+                        [chainId: number]: {
+                            token: string;
+                            minimumAmountPerEpoch: number;
+                            decimals: number;
+                            symbol: string;
+                        }[];
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,72 @@
+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(t.Numeric()),
+});
+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("/overview", 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 : query.chainId;
+    },
+    query,
+    tags: ["Merkl"],
+});

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

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

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("/parse", 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.d.ts

@@ -0,0 +1,58 @@
+import type Elysia from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    config: import("@sinclair/typebox").TString;
+    signature: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    payload: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                signature?: any;
+                config: string;
+                chainId: number;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    message: any;
+                    name: string;
+                    args?: undefined;
+                    parsedCampaign?: undefined;
+                    payload?: undefined;
+                    fee?: undefined;
+                } | {
+                    args: any;
+                    parsedCampaign: any;
+                    payload: any;
+                    fee: string | undefined;
+                    message?: undefined;
+                    name?: undefined;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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("/payload", 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.d.ts

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

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("/poolInfo", async ({ query }) => {
+    return await fetchPoolData(query.poolAddress, query.chainId);
+}, {
+    query,
+    tags: ["Protocols"],
+});