@merkl/api 0.9.15

package/dist/src/modules/v4/dynamicData/dynamicData.service.js

@@ -0,0 +1,131 @@
+import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
+import { HttpError } from "@/errors";
+import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
+import bigintToString from "@/utils/bigintToString";
+import { log } from "@/utils/logger";
+import { Campaign, NETWORK_LABELS } from "@sdk";
+import { Campaign as CampaignEnum } from "@sdk";
+import { AprService } from "../apr";
+import { OpportunityRepository } from "../opportunity/opportunity.repository";
+import { RewardService } from "../reward";
+import { TvlService } from "../tvl";
+export class DynamicDataService {
+    static async queryERC20DynamicData(chainId, tokenAddress, decimals = 18) {
+        const campaigns = [
+            {
+                campaignId: tokenAddress,
+                amount: "1000000000000000000", // 1 EXR in wei
+                campaignSubType: 0,
+                chainId: chainId,
+                computeChainId: chainId,
+                creator: "0xexamplecreatoraddress",
+                endTimestamp: 1672531199, // Example end timestamp
+                index: 0,
+                mainParameter: "0xexamplemainparameter",
+                rewardToken: "0xexamplerewardtokenaddress",
+                startTimestamp: 1672444800, // Example start timestamp
+                lastEligibilityRatio: 1,
+                campaignParameters: {
+                    blacklist: [],
+                    decimalsRewardToken: 18,
+                    decimalsTargetToken: decimals,
+                    duration: 30,
+                    whitelist: [],
+                    forwarders: [],
+                    hooks: [],
+                    shouldIgnore: false,
+                    symbolRewardToken: "EXR",
+                    symbolTargetToken: "EXT",
+                    targetToken: tokenAddress,
+                },
+                campaignType: Campaign.ERC20,
+            },
+        ];
+        log.info(`querying mock campaign on chain: ${NETWORK_LABELS[chainId]}`);
+        const result = await dynamicDataBuilderFactory(Campaign.ERC20).build(Number(chainId), campaigns);
+        return {
+            priceTargetToken: result[0]?.typeInfo.priceTargetToken,
+            totalSupply: result[0]?.typeInfo.totalSupply,
+            blacklistedSupply: result[0]?.typeInfo.blacklistedSupply,
+            cardName: result[0]?.typeInfo.cardName,
+            tvl: result[0]?.typeInfo.tvl,
+            type: result[0]?.type ?? "defaultType",
+        };
+    }
+    static async updateForCampaignType(campaigns, type) {
+        const chainId = campaigns[0].computeChainId;
+        const dynamicDataArray = [];
+        const dynamicData = await dynamicDataBuilderFactory(typeof type === "number" ? type : Campaign[type]).build(chainId, campaigns);
+        const oppMap = {};
+        for (const data of dynamicData) {
+            if (!!data) {
+                // Main Parameter OVERRIDING
+                if (data.campaignType === CampaignEnum.SILO && data.campaignParameters.whitelist?.length === 1)
+                    data.mainParameter = `${data.mainParameter}-${data.campaignParameters.whitelist[0]}`;
+                if (!oppMap[`${data.campaignType}_${data.mainParameter}`])
+                    oppMap[`${data.campaignType}_${data.mainParameter}`] = {};
+                oppMap[`${data.campaignType}_${data.mainParameter}`][data.campaignId] = data;
+            }
+        }
+        for (const entry of Object.entries(oppMap)) {
+            const [type, mainParameter] = entry[0].split("_");
+            const apr = AprService.extractFromDynamicData(+type, Object.values(entry[1]));
+            const tvl = TvlService.extractFromDynamicData(+type, Object.values(entry[1]));
+            const dailyRewards = await RewardService.extractDailyRewardsRecordFromDynamicData(+type, Object.values(entry[1]));
+            const opportunityId = OpportunityService.hashId({
+                chainId,
+                identifier: mainParameter,
+                type: Campaign[+type],
+            });
+            try {
+                await OpportunityRepository.updateRecords(opportunityId, apr, tvl, dailyRewards);
+            }
+            catch (err) {
+                throw new HttpError("Failed to update dynamic data", 500, {
+                    err,
+                    opportunityId,
+                    campaigns: Object.values(entry[1]),
+                    dynamicData: bigintToString({
+                        campaignId: Object.values(entry[1])[0].campaignId,
+                        apr,
+                        tvl,
+                        dailyRewards,
+                    }),
+                });
+            }
+            dynamicDataArray.push(bigintToString({ campaignId: Object.values(entry[1])[0].campaignId, apr, tvl, dailyRewards }));
+        }
+        return dynamicDataArray;
+    }
+    static async updateForCampaigns(campaigns) {
+        const campaignTypeToCampaigns = new Map();
+        for (const campaign of campaigns) {
+            const type = campaign.campaignType;
+            let campaigns = campaignTypeToCampaigns.get(campaign.campaignType);
+            if (!campaigns)
+                campaigns = [campaign];
+            else
+                campaigns.push(campaign);
+            campaignTypeToCampaigns.set(type, campaigns);
+        }
+        const dynamicDataArray = [];
+        for (const [campaignType, campaigns] of campaignTypeToCampaigns.entries()) {
+            try {
+                log.info(`updating dynamic data for ${campaigns.length} campaigns of type ${CampaignEnum[campaignType]}`);
+                try {
+                    dynamicDataArray.push(await DynamicDataService.updateForCampaignType(campaigns, campaignType));
+                }
+                catch (err) {
+                    console.error(`Failed to update dynamic data for campaign type ${CampaignEnum[campaignType]}`, err);
+                }
+            }
+            catch (err) {
+                throw new HttpError(`Failed to update dynamic data for campaign type ${CampaignEnum[campaignType]}`, 500, {
+                    err: err,
+                    campaigns: campaigns,
+                });
+            }
+        }
+        return dynamicDataArray.flat();
+    }
+}

package/dist/src/modules/v4/enso/enso.model.d.ts

@@ -0,0 +1,166 @@
+export declare const slugToProtocolId: {
+    "uniswap-v2": "uniswap";
+    "aave-v3": "aave";
+    "aave-v2": "aave";
+    "aave-static-atokens": "aave";
+    "camelot-v2": "camelot";
+    "meta-morpho": "morpho";
+    "morpho-blue-vaults": "morpho";
+    "balancer-v2": "balancer";
+    "balancer-gauge": "balancer";
+    "aura-lp": "aura";
+    aura: "aura";
+    beefy: "beefy";
+    venus: "venus";
+    "compound-v3": "compound";
+    "curve-gauge": "curve";
+    "euler-v2": "euler";
+    fluid: "fluid";
+    fraxlend: "frax";
+    "frax-ether": "frax";
+    "gearbox-v3": "gearbox";
+    gearbox: "gearbox";
+    moonwell: "moonwell";
+    "pancakeswap-amm-v3": "pancakeswap";
+    "quickswap-dex": "quickswap";
+    "silo-protected": "silo";
+    silo: "silo";
+    "velodrome-v2-staking": "velodrome";
+    zerolend: "zerolend";
+};
+export type EnsoSlug = keyof typeof slugToProtocolId;
+export declare const apiTypes: {
+    "/v1/protocols": {
+        query: import("@sinclair/typebox").TObject<{
+            slug: import("@sinclair/typebox").TString;
+        }>;
+        response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            slug: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            desription: import("@sinclair/typebox").TString;
+            url: import("@sinclair/typebox").TString;
+            logosUri: import("@sinclair/typebox").TString;
+            chains: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                id: import("@sinclair/typebox").TNumber;
+                name: import("@sinclair/typebox").TString;
+            }>>;
+        }>>;
+    };
+    "/v1/tokens": {
+        query: import("@sinclair/typebox").TObject<{
+            protocolSlug: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            primaryAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            chainId: import("@sinclair/typebox").TNumber;
+            type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<{
+                defi: "defi";
+                base: "base";
+            }>>;
+            page: import("@sinclair/typebox").TNumber;
+            inludeMetadata: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        response: import("@sinclair/typebox").TObject<{
+            data: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                chainId: import("@sinclair/typebox").TNumber;
+                address: import("@sinclair/typebox").TString;
+                type: import("@sinclair/typebox").TEnum<{
+                    defi: "defi";
+                    base: "base";
+                }>;
+                primaryAddress: import("@sinclair/typebox").TString;
+                underlyingTokens: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    address: import("@sinclair/typebox").TString;
+                    chainId: import("@sinclair/typebox").TNumber;
+                    type: import("@sinclair/typebox").TEnum<{
+                        defi: "defi";
+                        base: "base";
+                    }>;
+                }>>;
+                apy: import("@sinclair/typebox").TNumber;
+            }>>;
+            meta: import("@sinclair/typebox").TObject<{
+                total: import("@sinclair/typebox").TNumber;
+                lastPage: import("@sinclair/typebox").TNumber;
+                currentPage: import("@sinclair/typebox").TNumber;
+                perPage: import("@sinclair/typebox").TNumber;
+                prev: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>;
+                next: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>;
+            }>;
+        }>;
+    };
+    "/v1/shortcuts/quote": {
+        query: import("@sinclair/typebox").TObject<{
+            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            fromAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            routingStrategy: import("@sinclair/typebox").TEnum<{
+                ensowallet: "ensowallet";
+                delegate: "delegate";
+                router: "router";
+            }>;
+            feeReceiver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            amountIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            fee: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            disableRFQs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            ignoreAggregators: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            ignoreStandards: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        }>;
+        response: import("@sinclair/typebox").TObject<{
+            gas: import("@sinclair/typebox").TString;
+            amountOut: import("@sinclair/typebox").TObject<{}>;
+            priceImpact: import("@sinclair/typebox").TNumber;
+            feeAmount: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        }>;
+    };
+    "/v1/shortcuts/route": {
+        query: import("@sinclair/typebox").TObject<{
+            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            fromAddress: import("@sinclair/typebox").TString;
+            routingStrategy: import("@sinclair/typebox").TEnum<{
+                ensowallet: "ensowallet";
+                delegate: "delegate";
+                router: "router";
+            }>;
+            receiver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            spender: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            amountIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            amountOut: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            minAmountOut: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            slippage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            fee: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            feeReceiver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            disableRFQs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            ignoreAggregators: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            ignoreStandards: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        }>;
+        response: import("@sinclair/typebox").TObject<{
+            gas: import("@sinclair/typebox").TString;
+            amountOut: import("@sinclair/typebox").TString;
+            priceImpact: import("@sinclair/typebox").TNumber;
+            feeAmount: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            createAt: import("@sinclair/typebox").TNumber;
+            route: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                action: import("@sinclair/typebox").TLiteral<"swap">;
+                protocol: import("@sinclair/typebox").TString;
+                tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+                tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>, import("@sinclair/typebox").TObject<{
+                action: import("@sinclair/typebox").TLiteral<"deposit">;
+                primary: import("@sinclair/typebox").TString;
+                tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+                tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>]>>;
+            tx: import("@sinclair/typebox").TObject<{
+                data: import("@sinclair/typebox").TString;
+                to: import("@sinclair/typebox").TString;
+                from: import("@sinclair/typebox").TString;
+                value: import("@sinclair/typebox").TString;
+            }>;
+        }>;
+    };
+};
+export type EnsoRoute = keyof typeof apiTypes;
+export type EnsoApi<T extends EnsoRoute> = (typeof apiTypes)[T];

package/dist/src/modules/v4/enso/enso.model.js

@@ -0,0 +1,147 @@
+import { t } from "elysia";
+export const slugToProtocolId = {
+    "uniswap-v2": "uniswap",
+    "aave-v3": "aave",
+    "aave-v2": "aave",
+    "aave-static-atokens": "aave",
+    "camelot-v2": "camelot",
+    "meta-morpho": "morpho",
+    "morpho-blue-vaults": "morpho",
+    "balancer-v2": "balancer",
+    "balancer-gauge": "balancer",
+    "aura-lp": "aura",
+    aura: "aura",
+    beefy: "beefy",
+    venus: "venus",
+    "compound-v3": "compound",
+    "curve-gauge": "curve",
+    "euler-v2": "euler",
+    fluid: "fluid",
+    fraxlend: "frax",
+    "frax-ether": "frax",
+    "gearbox-v3": "gearbox",
+    gearbox: "gearbox",
+    moonwell: "moonwell",
+    "pancakeswap-amm-v3": "pancakeswap",
+    "quickswap-dex": "quickswap",
+    "silo-protected": "silo",
+    silo: "silo",
+    "velodrome-v2-staking": "velodrome",
+    zerolend: "zerolend",
+};
+export const apiTypes = {
+    "/v1/protocols": {
+        query: t.Object({
+            slug: t.String({ example: "uniswap-v2" }),
+        }),
+        response: t.Array(t.Object({
+            slug: t.String({ example: "uniswap-v2" }),
+            name: t.String({ example: "Uniswap V2" }),
+            desription: t.String(),
+            url: t.String(),
+            logosUri: t.String(),
+            chains: t.Array(t.Object({ id: t.Number(), name: t.String() })),
+        })),
+    },
+    "/v1/tokens": {
+        query: t.Object({
+            protocolSlug: t.Optional(t.String({ example: "uniswap-v2" })),
+            primaryAddress: t.Optional(t.String({ description: "Ethereum address for contract interaction of defi token" })),
+            address: t.Optional(t.String({ description: "Ethereum address of the token" })),
+            chainId: t.Number(),
+            type: t.Optional(t.Enum({ defi: "defi", base: "base" })),
+            page: t.Number(),
+            inludeMetadata: t.Optional(t.String()),
+        }),
+        response: t.Object({
+            data: t.Array(t.Object({
+                chainId: t.Number(),
+                address: t.String(),
+                type: t.Enum({ defi: "defi", base: "base" }),
+                primaryAddress: t.String({ description: "Ethereum address for contract interaction of defi token" }),
+                underlyingTokens: t.Array(t.Object({
+                    address: t.String(),
+                    chainId: t.Number(),
+                    type: t.Enum({ defi: "defi", base: "base" }),
+                })),
+                apy: t.Number(),
+            })),
+            meta: t.Object({
+                total: t.Number(),
+                lastPage: t.Number(),
+                currentPage: t.Number(),
+                perPage: t.Number(),
+                prev: t.Union([t.Null(), t.Number()]),
+                next: t.Union([t.Null(), t.Number()]),
+            }),
+        }),
+    },
+    "/v1/shortcuts/quote": {
+        query: t.Object({
+            chainId: t.Optional(t.Numeric()),
+            fromAddress: t.Optional(t.String()),
+            routingStrategy: t.Enum({ ensowallet: "ensowallet", delegate: "delegate", router: "router" }),
+            feeReceiver: t.Optional(t.String()),
+            tokenIn: t.Array(t.String()),
+            tokenOut: t.Array(t.String()),
+            amountIn: t.Array(t.String()),
+            fee: t.Optional(t.Array(t.String())),
+            disableRFQs: t.Optional(t.Boolean()),
+            ignoreAggregators: t.Optional(t.Array(t.String())),
+            ignoreStandards: t.Optional(t.Array(t.String())),
+        }),
+        response: t.Object({
+            gas: t.String(),
+            amountOut: t.Object({}),
+            priceImpact: t.Number(),
+            feeAmount: t.Array(t.String()),
+        }),
+    },
+    "/v1/shortcuts/route": {
+        query: t.Object({
+            chainId: t.Optional(t.Numeric()),
+            fromAddress: t.String(),
+            routingStrategy: t.Enum({ ensowallet: "ensowallet", delegate: "delegate", router: "router" }),
+            receiver: t.Optional(t.String()),
+            spender: t.Optional(t.String()),
+            amountIn: t.Array(t.String()),
+            amountOut: t.Optional(t.Array(t.String())),
+            minAmountOut: t.Optional(t.Array(t.String())),
+            slippage: t.Optional(t.String()),
+            fee: t.Optional(t.Array(t.String())),
+            feeReceiver: t.Optional(t.String()),
+            disableRFQs: t.Optional(t.Boolean()),
+            ignoreAggregators: t.Optional(t.Array(t.String())),
+            ignoreStandards: t.Optional(t.Array(t.String())),
+            tokenIn: t.Array(t.String()),
+            tokenOut: t.Array(t.String()),
+        }),
+        response: t.Object({
+            gas: t.String(),
+            amountOut: t.String(),
+            priceImpact: t.Number(),
+            feeAmount: t.Array(t.String()),
+            createAt: t.Number(),
+            route: t.Array(t.Union([
+                t.Object({
+                    action: t.Literal("swap"),
+                    protocol: t.String(),
+                    tokenIn: t.Array(t.String()),
+                    tokenOut: t.Array(t.String()),
+                }),
+                t.Object({
+                    action: t.Literal("deposit"),
+                    primary: t.String(),
+                    tokenIn: t.Array(t.String()),
+                    tokenOut: t.Array(t.String()),
+                }),
+            ])),
+            tx: t.Object({
+                data: t.String(),
+                to: t.String(),
+                from: t.String(),
+                value: t.String(),
+            }),
+        }),
+    },
+};

package/dist/src/modules/v4/enso/enso.service.d.ts

@@ -0,0 +1,69 @@
+import type { GetInteractionProtocolsQuery, InteractionAction, InteractionTarget, Router } from "@/modules/v4/interaction/interaction.model";
+import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
+import { type EnsoApi, type EnsoSlug } from "./enso.model";
+export declare abstract class EnsoService {
+    #private;
+    static getSlug(protocolId: ProtocolId | string): EnsoSlug | undefined;
+    static getProtocolId(slug: EnsoSlug | string): ProtocolId | undefined;
+    static getCompatibleProtocols(query: GetInteractionProtocolsQuery): Promise<({
+        id: string;
+        name: string;
+        url: string;
+        description: string;
+        tags: string[];
+        icon: string;
+    } & {
+        dailyRewards?: number | undefined;
+        numberOfLiveCampaigns?: number | undefined;
+        opportunityLiveTags?: string[] | undefined;
+    })[]>;
+    static getTokens(chainId: number, slug: EnsoSlug, identifier?: string): Promise<{
+        type: "base" | "defi";
+        address: string;
+        chainId: number;
+        primaryAddress: string;
+        underlyingTokens: {
+            type: "base" | "defi";
+            address: string;
+            chainId: number;
+        }[];
+        apy: number;
+    }[]>;
+    static getQuote(query: EnsoApi<"/v1/shortcuts/quote">["query"]["static"]): Promise<{
+        amountOut: {};
+        gas: string;
+        feeAmount: string[];
+        priceImpact: number;
+    }>;
+    static getTransaction(query: EnsoApi<"/v1/shortcuts/route">["query"]["static"]): Promise<{
+        route: ({
+            protocol: string;
+            action: "swap";
+            tokenIn: string[];
+            tokenOut: string[];
+        } | {
+            action: "deposit";
+            primary: string;
+            tokenIn: string[];
+            tokenOut: string[];
+        })[];
+        amountOut: string;
+        gas: string;
+        feeAmount: string[];
+        priceImpact: number;
+        createAt: number;
+        tx: {
+            data: string;
+            from: string;
+            value: string;
+            to: string;
+        };
+    }>;
+    static getActions(chainId: number, route: EnsoApi<"/v1/shortcuts/route">["response"]["static"]["route"], amountOut: bigint): Promise<InteractionAction[]>;
+    static getTargetsFromTokens(tokens: Awaited<ReturnType<typeof EnsoService.getTokens>>): Promise<InteractionTarget[]>;
+    /**
+     * Defines abstract router functions
+     * @returns Router
+     */
+    static getRouter(): Router;
+}

package/dist/src/modules/v4/enso/enso.service.js

@@ -0,0 +1,116 @@
+import { ProtocolService } from "@/modules/v4/protocol/protocol.service";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { slugToProtocolId } from "./enso.model";
+const ENSO = "https://api.enso.finance/api";
+export class EnsoService {
+    static async #fetch(route, params) {
+        const res = await fetch(`${ENSO}${route}?${params?.query ? new URLSearchParams(params?.query) : ""}`, {
+            headers: new Headers({
+                Authorization: `Bearer ${"8dbbda50-6ed5-4bda-bf54-ea2796602057"}`,
+                "Content-Type": "application/json",
+            }),
+        });
+        const json = await res.json();
+        if (res.status !== 200)
+            throw new Error(json?.message);
+        return json;
+    }
+    static getSlug(protocolId) {
+        const slug = Object.entries(slugToProtocolId).find(([_slug, id]) => id === protocolId)?.[0];
+        return slug;
+    }
+    static getProtocolId(slug) {
+        return slugToProtocolId[slug];
+    }
+    static async getCompatibleProtocols(query) {
+        const ensoProtocols = await EnsoService.#fetch("/v1/protocols");
+        const protocolIds = ensoProtocols
+            .filter(p => query.chainId === undefined || p.chains.some(c => c.id === query.chainId))
+            .map(p => EnsoService.getProtocolId(p.slug))
+            .filter(id => id !== undefined);
+        return await ProtocolService.findMany({
+            id: protocolIds.length === 1 ? protocolIds[0] : undefined,
+            ids: protocolIds.length > 1 ? protocolIds : undefined,
+        });
+    }
+    static async getTokens(chainId, slug, identifier) {
+        const tokens = await EnsoService.#fetch("/v1/tokens", {
+            query: identifier
+                ? { protocolSlug: slug, chainId, page: 1, address: identifier }
+                : { protocolSlug: slug, chainId, page: 1 },
+        });
+        return tokens.data;
+    }
+    static async getQuote(query) {
+        return await EnsoService.#fetch("/v1/shortcuts/quote", { query });
+    }
+    static async getTransaction(query) {
+        return await EnsoService.#fetch("/v1/shortcuts/route", { query });
+    }
+    static async getActions(chainId, route, amountOut) {
+        return await Promise.all(route.map(async (r) => {
+            switch (r.action) {
+                case "deposit": {
+                    const tokensIn = (await TokenService.findManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })))).filter(a => !!a);
+                    const [tokenOut] = await TokenService.findManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
+                    return {
+                        action: "deposit",
+                        tokens: tokensIn,
+                        tokensOut: [{ ...tokenOut, amount: amountOut }],
+                    };
+                }
+                case "swap": {
+                    const [from] = await TokenService.findManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
+                    const [to] = await TokenService.findManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
+                    return { action: "swap", from: from, to: to };
+                }
+            }
+        }));
+    }
+    static async getTargetsFromTokens(tokens) {
+        const targets = [];
+        for (const { address, underlyingTokens, ...target } of tokens) {
+            try {
+                targets.push({
+                    provider: "enso",
+                    chainId: target.chainId,
+                    identifier: address,
+                });
+            }
+            catch { }
+        }
+        return targets;
+    }
+    /**
+     * Defines abstract router functions
+     * @returns Router
+     */
+    static getRouter() {
+        return {
+            name: "enso",
+            async getTarget(chainId, protocolId, identifier) {
+                const slug = EnsoService.getSlug(protocolId);
+                if (!slug)
+                    return;
+                const tokens = await EnsoService.getTokens(chainId, slug, identifier);
+                const targets = await EnsoService.getTargetsFromTokens(tokens);
+                return targets?.[0];
+            },
+            async getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, options) {
+                const { tx, ...quote } = await EnsoService.getTransaction({
+                    fromAddress: userAddress,
+                    tokenIn: [fromTokenAddress],
+                    tokenOut: [identifier],
+                    routingStrategy: "router",
+                    chainId,
+                    amountIn: [fromTokenAmount.toString()],
+                    slippage: options.slippage?.toString(),
+                });
+                const [LpToken] = await TokenService.findManyOrCreate([{ address: identifier, chainId }]);
+                const depositValue = await TokenService.getValue([{ ...LpToken, amount: BigInt(quote.amountOut) }]);
+                const actions = await EnsoService.getActions(chainId, quote.route, BigInt(quote.amountOut));
+                return { transaction: tx, depositValue: depositValue, actions };
+            },
+        };
+    }
+}

package/dist/src/modules/v4/explorer/explorer.controller.d.ts

@@ -0,0 +1,45 @@
+import Elysia from "elysia";
+export declare const ExplorerController: Elysia<"/explorers", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    explorers: {
+        post: {
+            body: {
+                type: "ETHERSCAN" | "BLOCKSCOUT";
+                url: string;
+                chainId: number;
+            };
+            params: {};
+            query: unknown;
+            headers: {
+                authorization: string;
+            };
+            response: {
+                200: {
+                    id: string;
+                    type: import("@db/api").$Enums.ExplorerType;
+                    url: string;
+                    chainId: number;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;