@merkl/api 0.9.15

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

@@ -0,0 +1,70 @@
+import Elysia from "elysia";
+import app from "./app";
+import blacklist from "./blacklist";
+import campaignClaims from "./campaignClaims";
+import campaignUnclaimed from "./campaignUnclaimed";
+import campaigns from "./campaigns";
+import campaignsForMainParameter from "./campaignsForMainParameter";
+import campaignsRewardsReport from "./campaignsRewardsReport";
+import claims from "./claims";
+import compoundV2 from "./compoundV2";
+import createCampaign from "./createCampaign";
+import dolomite from "./dolomite";
+import euler from "./euler";
+import fetch from "./fetch";
+import health from "./health";
+import lostyield from "./lostyield";
+import merkl from "./merkl";
+import morphoMarkets from "./morphoMarkets";
+import morphoVaults from "./morphoVaults";
+import multiChainPositions from "./multiChainPositions";
+import opportunity from "./opportunity";
+import overview from "./overview";
+import parse from "./parse";
+import payload from "./payload";
+import poolInfo from "./poolInfo";
+import positions from "./positions";
+import radiant from "./radiant";
+import recipients from "./recipients";
+import rewards from "./rewards";
+import rewardsReport from "./rewardsReport";
+import silo from "./silo";
+import token from "./token";
+import uniswapv4 from "./uniswapv4";
+import updates from "./updates";
+import userRewards from "./userRewards";
+export const v3 = new Elysia({ tags: ["v3"], prefix: "/v3" })
+    .use(app)
+    .use(blacklist)
+    .use(campaignClaims)
+    .use(campaigns)
+    .use(campaignsForMainParameter)
+    .use(campaignsRewardsReport)
+    .use(campaignUnclaimed)
+    .use(claims)
+    .use(compoundV2)
+    .use(createCampaign)
+    .use(dolomite)
+    .use(euler)
+    .use(fetch)
+    .use(health)
+    .use(lostyield)
+    .use(merkl)
+    .use(morphoMarkets)
+    .use(morphoVaults)
+    .use(multiChainPositions)
+    .use(opportunity)
+    .use(overview)
+    .use(parse)
+    .use(payload)
+    .use(poolInfo)
+    .use(positions)
+    .use(radiant)
+    .use(recipients)
+    .use(rewards)
+    .use(rewardsReport)
+    .use(silo)
+    .use(token)
+    .use(updates)
+    .use(userRewards)
+    .use(uniswapv4);

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

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

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("/silo", async (request) => {
+    const chainId = request.query.chainId;
+    return await getSiloMarketsWithCache(chainId, request.query.repository);
+}, {
+    query,
+    tags: ["Protocols"],
+});

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

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

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("/token", async ({ query: { address, chainId } }) => {
+    return await executeSimple(chainId, getTokenInfo(address));
+}, {
+    query,
+    response: { 200: response },
+    tags: ["Onchain"],
+});

package/dist/src/routes/v3/twt/participants.d.ts

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

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

@@ -0,0 +1,63 @@
+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.d.ts

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

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

@@ -0,0 +1,9 @@
+import { getUniswapV4PoolsWithCache } from "@/engine/dynamicData/utils/getUniswapV4Pools";
+import { t } from "elysia";
+export const response = t.Array(t.Object({ address: t.String(), asset: t.String(), chaind: t.Number(), debtTokenAddress: t.String() }));
+export default (app) => app.get("/uniswapv4", async () => {
+    return await getUniswapV4PoolsWithCache();
+}, {
+    query: t.Object({}),
+    tags: ["Protocols"],
+});

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

@@ -0,0 +1,53 @@
+import type Elysia from "elysia";
+/**
+ * @deprecated - to remove in favor of new status page
+ */
+export type UpdatesT = {
+    [chainId: number]: {
+        [campaignId: string]: number;
+    };
+};
+export declare const query: import("@sinclair/typebox").TObject<{}>;
+export declare const response: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    updates: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {};
+            headers: unknown;
+            response: {
+                200: {
+                    [x: number]: {
+                        [campaignId: string]: number;
+                    };
+                };
+                readonly 400: {
+                    message?: string | undefined;
+                    error: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,69 @@
+import type Elysia from "elysia";
+/**
+ * @deprecated - conversion to v4 done
+ */
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    reloadChainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    mainParameter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    proof: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    rewardToken: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    user: import("@sinclair/typebox").TString;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    userRewards: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                rewardToken?: string | undefined;
+                proof?: string | undefined;
+                mainParameter?: string | undefined;
+                reloadChainId?: number | undefined;
+                chainId: number;
+                user: string;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    [x: string]: {
+                        pending?: string | undefined;
+                        proof?: string[] | undefined;
+                        symbol: string;
+                        decimals: number;
+                        unclaimed: string;
+                        accumulated: string;
+                        reasons: {
+                            [x: string]: {
+                                pending?: string | undefined;
+                                unclaimed: string;
+                                accumulated: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,62 @@
+import checkQueryAddressValidity from "@/hooks/checkQueryAddressValidity";
+import { RewardService, UserRewardV3Dto } from "@/modules/v4/reward";
+import { RewardConvertorService } from "@/modules/v4/reward/reward.converter";
+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"],
+});