@merkl/api 0.10.129 → 0.10.130

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

@@ -0,0 +1,203 @@
+import { HttpError } from "../../../errors";
+import { campaignsDynamicData } from "../../../libs/campaigns/campaignsDynamicData";
+import { campaignTypeToEnumMap, } from "./";
+import { CampaignRepository } from "./campaign.repository";
+import { OpportunityService } from "../opportunity";
+import { executeSimple } from "../../../utils/execute";
+import { log } from "../../../utils/logger";
+import { NETWORK_LABELS } from "@sdk";
+import moment from "moment";
+import { StatusService } from "../status";
+export class CampaignService {
+    static hashId(campaign) {
+        return Bun.hash(`${campaign.distributionChain}${campaign.campaignId}`).toString();
+    }
+    static async create(campaign) {
+        const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
+        const opportunityMetadata = await OpportunityService.getMetadata({
+            id,
+            ...campaign,
+        });
+        return await CampaignRepository.upsert({ id, ...campaign }, opportunityMetadata);
+    }
+    static async createMany(campaigns) {
+        const campaignToOppMetadata = {};
+        const failedToFetchMetadata = [];
+        const campaignsToInsert = [];
+        await Promise.all(campaigns.map(async (campaign) => {
+            const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
+            campaign.computeChainId = campaign.computeChainId === 0 ? campaign.chainId : campaign.computeChainId;
+            try {
+                const oppMetadata = await OpportunityService.getMetadata({
+                    id,
+                    ...campaign,
+                });
+                campaignToOppMetadata[id] = oppMetadata;
+                campaignsToInsert.push({ id, ...campaign });
+            }
+            catch (err) {
+                log.error(`Cannot get Opportunity metadata for campaign ${campaign.campaignId} of type ${CampaignService.getTypeFromV3(campaign.type)}`, err);
+                failedToFetchMetadata.push(campaign);
+            }
+        }));
+        let { success, fail } = await CampaignRepository.upsertMany(campaignsToInsert, campaignToOppMetadata);
+        fail += failedToFetchMetadata.length;
+        return { success, fail };
+    }
+    /**
+     * Get the list of campaigns satisfying the query
+     * @param query
+     * @returns A list of campaigns
+     */
+    static async findMany(query) {
+        if (query.subType && !query.type) {
+            throw new HttpError("Bad Request: Cannot specify a subType without a type", 400);
+        }
+        const campaigns = await CampaignRepository.findMany(query);
+        return campaigns.map(CampaignService.format);
+    }
+    /**
+     * Counts the number of campaigns that complies to query
+     * @description used for pagination purposes
+     * @param query
+     * @returns the number of campaigns
+     */
+    static async countMany(query) {
+        if (query.subType && !query.type) {
+            throw new HttpError("Bad Request: Cannot specify a subType without a type", 400);
+        }
+        return await CampaignRepository.countMany(query);
+    }
+    static async checkIfExist(campaign) {
+        return await CampaignRepository.checkIfExist(campaign);
+    }
+    static async findUnique(campaign) {
+        return await CampaignRepository.findUnique(campaign);
+    }
+    static async findUniqueOrThrow(campaign) {
+        return await CampaignRepository.findUniqueOrThrow(campaign);
+    }
+    static async findCampaignsToProcess(distributionChainId) {
+        return (await CampaignRepository.findCampaignsToProcess(distributionChainId)).filter(campaign => campaign.endTimestamp > campaign.CampaignStatus[0].computedUntil);
+    }
+    static async pickCampaignToProcess(chainId) {
+        const campaigns = await CampaignService.findCampaignsToProcess(chainId);
+        for (const campaign of campaigns) {
+            try {
+                await StatusService.update({
+                    distributionChain: chainId,
+                    campaignId: campaign.campaignId,
+                    status: { value: "PROCESSING" },
+                });
+                return campaign.campaignId;
+            }
+            catch { }
+        }
+        throw new Error(`No campaign to process found on ${NETWORK_LABELS[chainId]}`);
+    }
+    static async fill(campaigns) {
+        const campaignsFromEngine = await CampaignRepository.getFromEngineDbWithId(campaigns);
+        for (const campaign of campaigns) {
+            if (campaignsFromEngine.findIndex(c => c.campaignId === campaign.campaignId) === -1) {
+                log.warn(`Campaign ${campaign.campaignId} on ${NETWORK_LABELS[campaign.distributionChain]} not found in engine db`);
+            }
+        }
+        return await CampaignService.createMany(campaignsFromEngine.map(campaign => {
+            return {
+                amount: campaign.amount,
+                chainId: campaign.chainId,
+                computeChainId: campaign.computeChainId,
+                creator: campaign.creator,
+                endTimestamp: campaign.endTimestamp.toString(),
+                campaignId: campaign.campaignId,
+                opportunityIdentifier: campaign.mainParameter,
+                params: JSON.stringify(campaign.campaignParameters),
+                rewardTokenAddress: campaign.rewardToken,
+                startTimestamp: campaign.startTimestamp.toString(),
+                type: campaign.campaignType,
+                subType: campaign.campaignSubType,
+            };
+        }));
+    }
+    static async fetchMissingCampaigns(chainId, campaignIds) {
+        const foundCampaignIds = (await CampaignRepository.findManyCampaignId(chainId)).reduce((acc, { campaignId }) => acc.add(CampaignService.hashId({ distributionChain: chainId, campaignId })), new Set());
+        const missingCampaigns = campaignIds.filter(campaignId => !foundCampaignIds.has(CampaignService.hashId(campaignId)));
+        if (!missingCampaigns.length)
+            return { success: 0, fail: 0 };
+        return await CampaignService.fill(missingCampaigns);
+    }
+    static async findChains() {
+        return await CampaignRepository.findChains();
+    }
+    /**
+     * Returns the campaign data
+     * @param type index of Campaign enum from sdk
+     * @returns CampaignType as db-related enum for v4
+     */
+    static getTypeFromV3(type) {
+        return Object.entries(campaignTypeToEnumMap).find(([_, v3]) => v3 === type)?.[0];
+    }
+    /**
+     * Split a campaigns array into three array for each status
+     * @param campaigns
+     * @param timestamp to compare to campaigns timestamps
+     * @returns a status => campaigns map
+     */
+    static splitOnStatus(campaigns, timestamp = moment().unix()) {
+        const past = campaigns.filter(({ endTimestamp: end }) => end <= timestamp);
+        const live = campaigns.filter(({ startTimestamp: start, endTimestamp: end }) => start <= timestamp && end > timestamp);
+        const soon = campaigns.filter(({ startTimestamp: start }) => start > timestamp);
+        return { past, live, soon };
+    }
+    /**
+     * Returns the campaign data
+     * @param chainId to fetch campaigns for
+     * @param timestamp from which campaigns endTimestamp are filtered
+     * @returns
+     */
+    static async getFromEngineDb(chainId, timestamp) {
+        return CampaignRepository.getFromEngineDb(chainId, timestamp);
+    }
+    /**
+     * Convert raw
+     * @param query
+     * @returns A list of opportunities
+     * TODO: remove this function in favor of prisma client extensions
+     */
+    static format(campaign) {
+        if (campaign === null)
+            return null;
+        const { DistributionChain, ComputeChain, RewardToken, params, ...c } = campaign;
+        return {
+            ...c,
+            params: params,
+            chain: ComputeChain,
+            rewardToken: RewardToken,
+            distributionChain: DistributionChain === null ? undefined : DistributionChain,
+        };
+    }
+    /**
+     * Fetches the campaign dynamic data for a v3 campaign onchain
+     * @param chainId
+     * @param campaignType
+     * @param campaigns of v3 type
+     * @returns
+     */
+    static async fetchDynamicData(chainId, campaignType, campaigns) {
+        const calls = campaignsDynamicData(chainId, campaigns, campaignTypeToEnumMap[campaignType]);
+        return await executeSimple(chainId, calls);
+    }
+    /**
+     * Shortcut to get daily amount from total
+     * @param start timestamp
+     * @param end timestamp
+     * @param amount
+     * @returns daily token amount
+     */
+    static getDailyAmount(start, end, amount) {
+        const timespan = Math.abs(Number(end - start));
+        const dayspan = Math.max(1, Math.floor(timespan / (60 * 60 * 24)));
+        const dailyAmount = BigInt(amount) / BigInt(dayspan);
+        return dailyAmount;
+    }
+}

package/dist/src/modules/v4/campaign/index.js

@@ -0,0 +1,3 @@
+export * from "./campaign.model";
+export * from "./campaign.service";
+export * from "./campaign.controller";

package/dist/src/modules/v4/chain/chain.controller.js

@@ -0,0 +1,40 @@
+import { AuthorizationHeadersDto } from "../../../guards/BackOffice.guard";
+import { TokenAuthGuard } from "../../../guards/TokenAuth.guard";
+import Elysia from "elysia";
+import { ExplorerService } from "../explorer";
+import { ChainUniqueDto, CreateChainExplorerDto, GetChainQueryDto } from "./chain.model";
+import { ChainService } from "./chain.service";
+// ─── Chains Controller ───────────────────────────────────────────────────────
+export const ChainController = new Elysia({ prefix: "/chains", detail: { tags: ["Chains"] } })
+    // ─── Get A Chain By Id ───────────────────────────────────────────────
+    .get("/:chainId", async ({ params: { chainId } }) => {
+    const chain = await ChainService.get(chainId);
+    if (!chain)
+        return null;
+    const { Explorer, ...rest } = chain;
+    return { explorers: chain.Explorer, ...rest };
+}, {
+    params: ChainUniqueDto,
+})
+    // ─── Get All Supported Chains ────────────────────────────────────────
+    .get("/", async ({ query }) => {
+    const chains = await ChainService.getMany(query);
+    return chains.map(({ Explorer, ...chain }) => ({ explorers: Explorer, ...chain }));
+}, {
+    query: GetChainQueryDto,
+})
+    .get("/count", async ({ query }) => {
+    return await ChainService.countMany(query);
+}, {
+    query: GetChainQueryDto,
+})
+    // ─── Get All Supported Chains ────────────────────────────────────────
+    .group("/explorers", app => {
+    return app.post("", async ({ body: { chainId, type, url } }) => {
+        return await ExplorerService.create(chainId, type, url);
+    }, {
+        beforeHandle: TokenAuthGuard,
+        headers: AuthorizationHeadersDto,
+        body: CreateChainExplorerDto,
+    });
+});

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

@@ -0,0 +1,17 @@
+import { ExplorerType } from "../../../../database/api/.generated";
+import { t } from "elysia";
+// ─── DTOs ────────────────────────────────────────────────────────────────────
+export const GetChainQueryDto = t.Object({
+    search: t.Optional(t.String()),
+});
+export const ChainUniqueDto = t.Object({
+    chainId: t.Numeric(),
+});
+export const ChainArrayDto = t.Object({
+    chainId: t.Union([t.Numeric(), t.Array(t.Numeric())]),
+});
+export const CreateChainExplorerDto = t.Object({
+    type: t.Enum(ExplorerType),
+    chainId: t.Number(),
+    url: t.String(),
+});

package/dist/src/modules/v4/chain/chain.repository.js

@@ -0,0 +1,64 @@
+import { campaignsDynamicData } from "../../../libs/campaigns/campaignsDynamicData";
+import { executeSimple } from "../../../utils/execute";
+import { apiDbClient } from "../../../utils/prisma";
+export class ChainRepository {
+    /**
+     * @param id ChainId
+     * @returns
+     */
+    static async read(id) {
+        //TODO: tweak query to not have 5
+        return apiDbClient.chain.findUnique({ where: { id }, include: { Explorer: { take: 5 } } });
+    }
+    static #transformQueryToPrismaFilters(query) {
+        return {
+            where: { name: { contains: query.search, mode: "insensitive" } },
+        };
+    }
+    /** Returns many chains based on query
+     * @param query object with fields to search for
+     * @returns
+     */
+    static async readMany(query) {
+        const args = ChainRepository.#transformQueryToPrismaFilters(query);
+        return apiDbClient.chain.findMany({
+            include: { Explorer: { take: 5 } },
+            ...args,
+        });
+    }
+    static async countMany(query) {
+        const args = ChainRepository.#transformQueryToPrismaFilters(query);
+        return apiDbClient.chain.count({
+            ...args,
+        });
+    }
+    /** Returns all chainIds in the database
+     */
+    static async readIds() {
+        return apiDbClient.chain.findMany({
+            select: { id: true },
+        });
+    }
+    /**
+     * Creates a new chain
+     * @param template for chain creation
+     * @returns
+     */
+    static async create(template) {
+        return apiDbClient.chain.create(template);
+    }
+    static async findMany() {
+        return apiDbClient.chain.findMany();
+    }
+    /**
+     * Fetches the campaign dynamic data for a v3 campaign onchain
+     * @param chainId
+     * @param campaignType
+     * @param campaigns of v3 type
+     * @returns
+     */
+    static async fetchDynamicDataV3(chainId, campaignType, campaigns) {
+        const calls = campaignsDynamicData(chainId, campaigns, campaignType);
+        return executeSimple(chainId, calls);
+    }
+}

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

@@ -0,0 +1,42 @@
+import { DistributorService } from "@sdk";
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
+import { ChainRepository } from "./chain.repository";
+export class ChainService {
+    static async get(chainId) {
+        return ChainRepository.read(chainId);
+    }
+    //TODO: determine find vs get nomenclature and cache handling
+    static async findMany() {
+        return await CacheService.wrap(TTLPresets.HOUR_4, ChainRepository.findMany);
+    }
+    static async getMany(query) {
+        return ChainRepository.readMany(query);
+    }
+    static async countMany(query) {
+        return ChainRepository.countMany(query);
+    }
+    /** List all chainIds available in the databse
+     * @warning some chains may not be fully integrated yet
+     * @returns an array of chainId
+     */
+    static async getIds() {
+        const ids = await ChainRepository.readIds();
+        return ids.map(({ id }) => id);
+    }
+    /** List all chainIds which have a distribituor (i.e. which is fully integrated)
+     * @returns an array of chainId
+     */
+    static async getSupportedIds() {
+        const ids = await ChainService.getIds();
+        const supportedIds = [];
+        for (const chainId of ids) {
+            try {
+                DistributorService(chainId);
+                supportedIds.push(chainId);
+            }
+            catch { }
+        }
+        return supportedIds;
+    }
+}

package/dist/src/modules/v4/chain/index.js

@@ -0,0 +1,3 @@
+export * from "./chain.controller";
+export * from "./chain.service";
+export * from "./chain.model";

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

@@ -0,0 +1,19 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
+import Elysia from "elysia";
+import { throwOnUnsupportedChainId } from "src/utils/throw";
+import { DynamicDataSourceIdentifier } from "./dynamicData.model";
+import { DynamicDataService } from "./dynamicData.service";
+// ─── DynamicDatas Controller ───────────────────────────────────────────────────────
+export const DynamicDataController = new Elysia({ prefix: "/dynamicData", detail: { tags: ["DynamicData"] } })
+    // ─── Get All DynamicDatas ──────────────────────────────────────────────────
+    // ─── Get type Info By Token Address ───────────────────────────────────────
+    .get("/chainId/:chainId/token/:tokenAddress", async ({ params }) => {
+    return await DynamicDataService.queryERC20DynamicData(params.chainId, params.tokenAddress);
+}, {
+    params: DynamicDataSourceIdentifier,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: ({ params, headers }) => {
+        BackOfficeGuard({ headers });
+        throwOnUnsupportedChainId(params.chainId);
+    },
+});

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

@@ -0,0 +1,6 @@
+import { t } from "elysia";
+// ─── DTOs ────────────────────────────────────────────────────────────────────
+export const DynamicDataSourceIdentifier = t.Object({
+    chainId: t.Numeric(),
+    tokenAddress: t.String(),
+});

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,49 @@
+import { campaignsDynamicData } from "../../../libs/campaigns/campaignsDynamicData";
+import { executeSimple } from "../../../utils/execute";
+import { log } from "../../../utils/logger";
+import { Campaign, NETWORK_LABELS } from "@sdk";
+export class DynamicDataService {
+    // ─── DynamicDatas ──────────────────────────────────────────────────────────
+    /** Fetches a single price */
+    static async queryERC20DynamicData(chainId, tokenAddress) {
+        const campaigns = [
+            {
+                campaignId: tokenAddress,
+                amount: "1000000000000000000", // 1 EXR in wei
+                campaignSubType: 0,
+                chainId: chainId,
+                computeChainId: 1,
+                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: 18,
+                    duration: 30,
+                    forwarders: [],
+                    hooks: [],
+                    shouldIgnore: false,
+                    symbolRewardToken: "EXR",
+                    symbolTargetToken: "EXT",
+                    targetToken: tokenAddress,
+                    whitelist: [],
+                },
+                campaignType: Campaign.ERC20,
+            },
+        ];
+        log.info(`querying mock campaign on chain: ${NETWORK_LABELS[chainId]}`);
+        const result = await executeSimple(Number(chainId), campaignsDynamicData(Number(chainId), campaigns, Campaign.ERC20));
+        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,
+        };
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from "./dynamicData.controller";
+export * from "./dynamicData.service";
+export * from "./dynamicData.model";

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

@@ -0,0 +1,108 @@
+import { t } from "elysia";
+export const slugToProtocolId = {
+    "uniswap-v2": "uniswap-v2",
+    "aave-v2": "aave",
+    "camelot-v2": "camelot",
+};
+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(),
+            inludeMetadatra: t.Optional(t.Boolean()),
+        }),
+        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(),
+            tx: t.Object({
+                data: t.String(),
+                to: t.String(),
+                from: t.String(),
+                value: t.String(),
+            }),
+        }),
+    },
+};

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

@@ -0,0 +1,46 @@
+import { ProtocolService } from "../protocol";
+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",
+            }),
+        });
+        if (res?.status !== 200)
+            throw "Unsucessful call";
+        return (await res.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 });
+    }
+    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 getDepositSchema(protocolId) { }
+}

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

@@ -0,0 +1,2 @@
+// ─── Schemas ─────────────────────────────────────────────────────────────────
+export {};

package/dist/src/modules/v4/explorer/explorer.repository.js

@@ -0,0 +1,23 @@
+import { apiDbClient } from "../../../utils/prisma";
+import { ExplorerService } from "./explorer.service";
+export class ExplorerRepository {
+    static async getByChainId(chainId) {
+        return await apiDbClient.explorer.findFirstOrThrow({ where: { chainId } });
+    }
+    /**
+     * Creates an explorer
+     * @param chainId to attach explorer to
+     * @param type that defines the subsequents links for transactions, addresses...
+     * @param url base url without / suffix
+     */
+    static async create(chainId, type, url) {
+        return apiDbClient.explorer.create({
+            data: {
+                chainId,
+                type,
+                url,
+                id: ExplorerService.hashId(type, chainId),
+            },
+        });
+    }
+}