@merkl/api 0.9.15

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

@@ -0,0 +1,46 @@
+import type Elysia from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    index: import("@sinclair/typebox").TNumber;
+}>;
+/** Fetch params  */
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    fetch: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                index: number;
+                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/fetch.js

@@ -0,0 +1,27 @@
+import { DistributionCreator__factory, parseCampaign, registry } from "@sdk";
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { providers } from "../../utils/providers";
+export const query = t.Object({
+    chainId: t.Numeric(),
+    index: t.Numeric(),
+});
+/** Fetch params  */
+export default (app) => app.use(checkQueryChainIdValidity()).get("/fetch", async (request) => {
+    const chainId = request.query.chainId;
+    /** Merkl reward manager contract */
+    const distributionCreator = DistributionCreator__factory.connect(registry(chainId)?.Merkl?.DistributionCreator, providers[chainId]);
+    const campaignStruct = await distributionCreator.campaignList(request.query.index);
+    try {
+        const parsingResult = await parseCampaign(chainId, { ...campaignStruct, amount: campaignStruct.amount.toString() }, 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/health.d.ts

@@ -0,0 +1,40 @@
+import type Elysia from "elysia";
+export declare const response: import("@sinclair/typebox").TObject<{
+    success: import("@sinclair/typebox").TBoolean;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    health: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {};
+            headers: unknown;
+            response: {
+                200: {
+                    success: boolean;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import { Redis } from "@/cache";
+import { t } from "elysia";
+export const response = t.Object({ success: t.Boolean() });
+export default (app) => app.get("/health", async () => {
+    // Check if the cache is working
+    await Redis.get("Prices");
+    return {
+        success: true,
+    };
+}, {
+    query: t.Object({}),
+    tags: ["Onchain"],
+});

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

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

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

@@ -0,0 +1,101 @@
+import { Redis } from "@/cache";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { getLastBlockBeforeWithCache } from "@/utils/lastBlockBefore";
+import { BN2Number, ChainId, DAY, ERC20Interface } from "@sdk";
+import { t } from "elysia";
+import { utils } from "ethers";
+import moment from "moment";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import { batchMulticallCallWithRetry } from "../../utils/generic";
+import { log } from "../../utils/logger";
+import { providers } from "../../utils/providers";
+const CONSTANTS = {
+    [ChainId.MAINNET]: [
+        utils.getAddress("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"),
+        utils.getAddress("0xdac17f958d2ee523a2206206994597c13d831ec7"),
+    ],
+    [ChainId.BASE]: [
+        utils.getAddress("0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"),
+        utils.getAddress("0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"),
+    ],
+    [ChainId.ARBITRUM]: [
+        utils.getAddress("0xaf88d065e77c8cc2239327c5edb3a432268e5831"),
+        utils.getAddress("0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9"),
+    ],
+    [ChainId.OPTIMISM]: [
+        utils.getAddress("0x0b2c639c533813f4aa9d7837caf62653d097ff85"),
+        utils.getAddress("0x94b008aa00579c1307b0ef2c499ad98a8ce58e58"),
+    ],
+    [ChainId.POLYGON]: [
+        utils.getAddress("0x3c499c542cef5e3811e1192ce70d8cc03d5c3359"),
+        utils.getAddress("0xc2132d05d31c914a87c6611c10748aeb04b58e8f"),
+    ],
+};
+const getLostYield = async (user) => {
+    const result = {};
+    const now = moment().unix();
+    const LOOKBACK = 30 * DAY;
+    const AVERAGING_PERIOD = 2 * DAY;
+    const promises = Object.keys(CONSTANTS).map(chainId => (async () => {
+        try {
+            const tokenList = await TokenService.findManyObjectPerAddress({
+                chainId: Number.parseInt(chainId),
+                verified: true,
+            });
+            result[chainId] = {};
+            for (const token of CONSTANTS[Number.parseInt(chainId)]) {
+                result[chainId][token] = { total: 0, yield: 0 };
+            }
+            const currentBlockNumber = await providers[Number.parseInt(chainId)].getBlockNumber();
+            const startBlockNumber = await getLastBlockBeforeWithCache(Math.floor((now - LOOKBACK) / AVERAGING_PERIOD) * AVERAGING_PERIOD, Number.parseInt(chainId));
+            const AVERAGING_PERIOD_IN_BLOCKS = Math.floor((currentBlockNumber - startBlockNumber) / (LOOKBACK / AVERAGING_PERIOD));
+            let blockNumber = startBlockNumber;
+            const averagingPromises = [];
+            let blocksByChain = 0;
+            while (blockNumber < currentBlockNumber) {
+                blocksByChain++;
+                averagingPromises.push((async () => {
+                    const calls = [];
+                    for (const token of CONSTANTS[Number.parseInt(chainId)]) {
+                        calls.push({
+                            target: token,
+                            callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
+                            allowFailure: true,
+                        });
+                    }
+                    // console.log(`Calling multicall with ${calls.length} calls for block ${blockNumber} on chain ${chainId}`);
+                    const results = await batchMulticallCallWithRetry(Number.parseInt(chainId), { calls, blockNumber });
+                    let i = 0;
+                    for (const token of CONSTANTS[Number.parseInt(chainId)]) {
+                        const tokenDetails = tokenList[utils.getAddress(token)];
+                        const balance = ERC20Interface.decodeFunctionResult("balanceOf", results[i++].returnData)[0];
+                        result[chainId][token].total += BN2Number(balance, tokenDetails.decimals);
+                    }
+                })());
+                blockNumber += AVERAGING_PERIOD_IN_BLOCKS;
+            }
+            await Promise.all(averagingPromises);
+            for (const token of CONSTANTS[Number.parseInt(chainId)]) {
+                result[chainId][token].total = result[chainId][token].total / blocksByChain;
+                result[chainId][token].yield = result[chainId][token].total * 0.04;
+            }
+        }
+        catch (e) {
+            log.error(`Failed to get yield data for ${user} on chain ${chainId}`, e);
+        }
+    })());
+    await Promise.all(promises);
+    return result;
+};
+export const query = t.Object({
+    user: t.String(),
+});
+export const response = t.Record(t.String({ title: "ChainId" }), t.Record(t.String({ title: "TokenAddress" }), t.Object({ total: t.Number(), yield: t.Number() })));
+export default (app) => app.use(checkQueryAddressValidity()).get("/lostyield", async ({ query }) => {
+    return await Redis.getOrSet(`LostYield_${query.user}`, getLostYield, query.user);
+}, {
+    query: t.Object({
+        user: t.String(),
+    }),
+    tags: ["Protocols"],
+});

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

@@ -0,0 +1,88 @@
+import { type Campaign, type CampaignDynamicData } from "@sdk";
+import { type Elysia } from "elysia";
+export type CampaignsReturnType = {
+    [chainId: number]: {
+        [type_mainParameter: string]: {
+            [campaignId: string]: CampaignDynamicData<Campaign>;
+        };
+    };
+};
+export declare const query: import("@sinclair/typebox").TObject<{
+    AMMs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    chainIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>>;
+    user: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    onlyLive: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const response: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+    merkleRoot: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    message: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    validRewardTokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        decimals: import("@sinclair/typebox").TNumber;
+        minimumAmountPerEpoch: import("@sinclair/typebox").TNumber;
+        symbol: import("@sinclair/typebox").TString;
+        token: import("@sinclair/typebox").TString;
+    }>>>;
+    pools: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        alm: import("@sinclair/typebox").TObject<{}>;
+        amm: import("@sinclair/typebox").TNumber;
+        ammAlgo: import("@sinclair/typebox").TNumber;
+        ammAlgoName: import("@sinclair/typebox").TString;
+        ammName: import("@sinclair/typebox").TString;
+        aprs: import("@sinclair/typebox").TObject<{}>;
+        chainId: import("@sinclair/typebox").TNumber;
+        decimalsToken0: import("@sinclair/typebox").TNumber;
+        decimalsToken1: import("@sinclair/typebox").TNumber;
+        disputeLive: import("@sinclair/typebox").TBoolean;
+        distributionData: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnknown>;
+        endOfDisputePeriod: import("@sinclair/typebox").TNumber;
+        meanAPR: import("@sinclair/typebox").TNumber;
+        pool: import("@sinclair/typebox").TString;
+        poolBalanceToken0: import("@sinclair/typebox").TNumber;
+        poolBalanceToken1: import("@sinclair/typebox").TNumber;
+        poolFee: import("@sinclair/typebox").TNumber;
+        poolTotalLiquidity: import("@sinclair/typebox").TNumber;
+        rewardsPerToken: import("@sinclair/typebox").TObject<{}>;
+        symbolToken0: import("@sinclair/typebox").TString;
+        symbolToken1: import("@sinclair/typebox").TString;
+        tick: import("@sinclair/typebox").TNumber;
+        token0: import("@sinclair/typebox").TString;
+        token1: import("@sinclair/typebox").TString;
+        tvl: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TNull]>;
+    }>>;
+}>>;
+export declare const merklRoute: ({ query, set }: any) => Promise<MerklAPIType>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    merkl: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                [x: string]: any;
+                200: any;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,119 @@
+import { getClamsInfo } from "@/libs/deprecated-merklv3";
+import { AMM, ChainId, isSupportedChain } from "@sdk";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import { InvalidParameter } from "../../utils/error";
+import { throwOnUnsupportedChainId } from "../../utils/throw";
+export const query = t.Object({
+    AMMs: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    chainIds: t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric())])),
+    user: t.Optional(t.String()),
+    onlyLive: t.Optional(t.String()),
+});
+export const response = t.Record(t.String({ title: "Merkl" }), t.Object({
+    merkleRoot: t.Optional(t.String()),
+    message: t.Optional(t.String()),
+    validRewardTokens: t.Optional(t.Array(t.Object({
+        decimals: t.Number(),
+        minimumAmountPerEpoch: t.Number(),
+        symbol: t.String(),
+        token: t.String(),
+    }))),
+    pools: t.Record(t.String(), t.Object({
+        alm: t.Object({}),
+        amm: t.Number(),
+        ammAlgo: t.Number(),
+        ammAlgoName: t.String(),
+        ammName: t.String(),
+        aprs: t.Object({}),
+        chainId: t.Number(),
+        decimalsToken0: t.Number(),
+        decimalsToken1: t.Number(),
+        disputeLive: t.Boolean(),
+        distributionData: t.Array(t.Unknown()),
+        endOfDisputePeriod: t.Number(),
+        meanAPR: t.Number(),
+        pool: t.String(),
+        poolBalanceToken0: t.Number(),
+        poolBalanceToken1: t.Number(),
+        poolFee: t.Number(),
+        poolTotalLiquidity: t.Number(),
+        rewardsPerToken: t.Object({}),
+        symbolToken0: t.String(),
+        symbolToken1: t.String(),
+        tick: t.Number(),
+        token0: t.String(),
+        token1: t.String(),
+        tvl: t.Union([t.Number(), t.Null()]),
+    })),
+}));
+export const merklRoute = async ({ query, set }) => {
+    const user = query.user;
+    let AMMs;
+    let rawAMMs = query.AMMs;
+    if (!rawAMMs) {
+        rawAMMs = query["AMMs[]"];
+    }
+    if (!rawAMMs) {
+        rawAMMs = query["AMMs[0]"];
+    }
+    if (!rawAMMs) {
+        AMMs = undefined;
+    }
+    else if (typeof rawAMMs === "string") {
+        if (rawAMMs.includes(",")) {
+            AMMs = rawAMMs.split(",");
+        }
+        else {
+            AMMs = [rawAMMs];
+        }
+    }
+    if (!!AMMs) {
+        AMMs = AMMs.map(amm => {
+            return amm.toLowerCase();
+        });
+        for (const filterAMM of AMMs) {
+            if (Object.keys(AMM)
+                .filter(amm => Number.isNaN(Number(amm)))
+                .map(amm => {
+                return amm.toLowerCase();
+            })
+                .indexOf(filterAMM.toLowerCase()) === -1) {
+                throw new InvalidParameter(`API for Merkl products by Angle Labs does not support this type of AMM: ${filterAMM}`);
+            }
+        }
+    }
+    let rawChainIds = query.chainIds;
+    if (!rawChainIds) {
+        rawChainIds = query["chainIds[]"];
+    }
+    if (!rawChainIds) {
+        rawChainIds = query["chainIds[0]"];
+    }
+    let chainIds;
+    if (!rawChainIds) {
+        chainIds = Object.keys(ChainId)
+            .map(k => Number.parseInt(k))
+            .filter(k => isSupportedChain(k, "merkl"));
+    }
+    else if (typeof rawChainIds === "number") {
+        chainIds = [rawChainIds];
+    }
+    else if (typeof rawChainIds === "string") {
+        chainIds = [Number.parseInt(rawChainIds)];
+    }
+    else {
+        chainIds = rawChainIds;
+    }
+    for (const chainId of chainIds)
+        throwOnUnsupportedChainId(chainId);
+    let onlyLive = false;
+    if (query.onlyLive === "true") {
+        onlyLive = true;
+    }
+    return getClamsInfo(chainIds, AMMs, user, onlyLive);
+};
+export default (app) => app.use(checkQueryAddressValidity()).get("/merkl", merklRoute, {
+    // query,
+    tags: ["Merkl"],
+});

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

@@ -0,0 +1,62 @@
+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<{
+    uniqueKey: import("@sinclair/typebox").TString;
+    whitelisted: import("@sinclair/typebox").TBoolean;
+    lltv: import("@sinclair/typebox").TNumber;
+    loanAsset: import("@sinclair/typebox").TObject<{
+        address: import("@sinclair/typebox").TString;
+        chain: import("@sinclair/typebox").TObject<{
+            network: import("@sinclair/typebox").TString;
+        }>;
+        symbol: import("@sinclair/typebox").TString;
+    }>;
+    collateralAsset: import("@sinclair/typebox").TObject<{
+        address: import("@sinclair/typebox").TString;
+        chain: import("@sinclair/typebox").TObject<{
+            network: 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: {};
+}, {
+    morphoMarkets: {
+        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/morphoMarkets.js

@@ -0,0 +1,27 @@
+import { getMorphoMarketsWithCache } from "@/libs/parse/marketsWithCache";
+import { MorphoSubCampaignType } from "@sdk";
+import { t } from "elysia";
+export const query = t.Object({
+    repository: t.String(),
+    chainId: t.Numeric(),
+});
+const asset = t.Object({
+    address: t.String(),
+    chain: t.Object({ network: t.String() }),
+    symbol: t.String(),
+});
+export const response = t.Array(t.Object({
+    uniqueKey: t.String(),
+    whitelisted: t.Boolean(),
+    lltv: t.Numeric(),
+    loanAsset: asset,
+    collateralAsset: asset,
+}));
+export default (app) => app.get("/morphoMarkets", async (request) => {
+    const chainId = request.query.chainId;
+    if (request.query.repository !== MorphoSubCampaignType.META.toString())
+        return await getMorphoMarketsWithCache(chainId, request.query.repository);
+}, {
+    query,
+    tags: ["Protocols"],
+});

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

@@ -0,0 +1,52 @@
+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<{
+    address: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    whitelisted: import("@sinclair/typebox").TBoolean;
+    symbol: import("@sinclair/typebox").TString;
+    chain: import("@sinclair/typebox").TObject<{
+        network: import("@sinclair/typebox").TString;
+    }>;
+}>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    morphoVaults: {
+        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/morphoVaults.js

@@ -0,0 +1,22 @@
+import { getMorphoMarketsWithCache } from "@/libs/parse/marketsWithCache";
+import { MorphoSubCampaignType } from "@sdk";
+import { t } from "elysia";
+export const query = t.Object({
+    repository: t.String(),
+    chainId: t.Numeric(),
+});
+export const response = t.Array(t.Object({
+    address: t.String(),
+    name: t.String(),
+    whitelisted: t.Boolean(),
+    symbol: t.String(),
+    chain: t.Object({ network: t.String() }),
+}));
+export default (app) => app.get("/morphoVaults", async (request) => {
+    const chainId = request.query.chainId;
+    if (request.query.repository === MorphoSubCampaignType.META.toString())
+        return await getMorphoMarketsWithCache(chainId, request.query.repository);
+}, {
+    query,
+    tags: ["Protocols"],
+});