@merkl/api 0.21.47 → 1.0.0

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

@@ -1,92 +0,0 @@
-import { TTLPresets } from "../cache/cache.model";
-import { CacheService } from "../cache/cache.service";
-import { CampaignService } from "../campaign/campaign.service";
-import { UserService } from "../user/user.service";
-import { CreatorRepository } from "./creator.repository";
-// ─── Creators Service ────────────────────────────────────────────────────────
-export class CreatorService {
-    /**
-     * Finds a creator from its id (i.e. "uniswap")
-     * @param id
-     * @returns creator
-     */
-    static async findUnique(id) {
-        return await CreatorRepository.findUnique(id);
-    }
-    /**
-     * Finds many creators
-     * @param id
-     * @returns creators[]
-     */
-    static async findMany(query) {
-        return await CreatorRepository.findMany(query);
-    }
-    /**
-     * Creates a creator
-     * @param creator {addresses, id, name}
-     */
-    static async create(creator) {
-        return await CreatorRepository.create(creator);
-    }
-    /**
-     * Updates data on a creator
-     * @notice will override the entire address array
-     * @param id of creator
-     * @param creator data for each field
-     */
-    static async update(id, creator) {
-        return await CreatorRepository.update(id, creator);
-    }
-    static async delete(id) {
-        return await CreatorRepository.delete(id);
-    }
-    static async getCreatorIdFromAddress(address) {
-        return await CacheService.wrap(TTLPresets.MIN_30, async () => (await UserService.findUniqueOrThrow(address)).creatorId);
-    }
-    static async getCreatorAddresses(id) {
-        const creator = await CreatorRepository.findUnique(id);
-        return creator.Users.map(user => user.address);
-    }
-    static async getGlobalDashboard(creatorAddress) {
-        const [pastCampaigns, liveCampaigns, futureCampaigns, creatorId] = await Promise.all([
-            CampaignService.getPastCampaigns({ creatorAddress }),
-            CampaignService.getLiveCampaigns({ creatorAddress }),
-            CampaignService.getFutureCampaigns({ creatorAddress }),
-            CreatorService.getCreatorIdFromAddress(creatorAddress),
-        ]);
-        const totalTvl = liveCampaigns.reduce((acc, campaign) => acc + campaign.Opportunity.tvl, 0);
-        // let totalWallets = 0;
-        const promises = [];
-        for (const campaign of liveCampaigns)
-            promises.push(CampaignService.getWalletCount(campaign.id));
-        const results = await Promise.all(promises);
-        const totalWallets = results.reduce((acc, walletCount) => acc + walletCount, 0);
-        return {
-            pastCampaigns: pastCampaigns.length,
-            liveCampaigns: liveCampaigns.length,
-            futureCampaigns: futureCampaigns.length,
-            totalTvl,
-            totalWallets,
-            totalCampaigns: pastCampaigns.length + liveCampaigns.length + futureCampaigns.length,
-            creatorId,
-        };
-    }
-    static async getCampaignsFor(creatorAddress, status) {
-        switch (status) {
-            case "PAST":
-                return CampaignService.getPastCampaigns({ creatorAddress });
-            case "LIVE":
-                return CampaignService.getLiveCampaigns({ creatorAddress });
-            case "FUTURE":
-                return CampaignService.getFutureCampaigns({ creatorAddress });
-            default:
-                return CampaignService.findMany({ creatorAddress });
-        }
-    }
-    static async getCampaignMetrics(campaignId) {
-        return await CampaignService.getMetrics(campaignId);
-    }
-    static async updateRebate(id, rebate) {
-        return await CreatorRepository.updateRebate(id, rebate);
-    }
-}

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

@@ -1,56 +0,0 @@
-import { t } from "elysia";
-// ─── DTOs ────────────────────────────────────────────────────────────────────
-export const DynamicDataSourceIdentifier = t.Object({
-    chainId: t.Numeric(),
-    tokenAddress: t.String(),
-    rewardTokenAddress: t.String(),
-    symbolRewardToken: t.String(),
-    decimals: t.Optional(t.Numeric()),
-});
-export const DynamicDataExtendedDto = t.Object({
-    targetTokenSymbol: t.Optional(t.String()),
-});
-export const SimplifiedCampaignDto = t.Object({
-    id: t.Optional(t.String()),
-    distributionChainId: t.Optional(t.Number()),
-    rewardTokenId: t.Optional(t.String()),
-    opportunityId: t.Optional(t.String()),
-    computeChainId: t.Number(),
-    chainId: t.Optional(t.Number()),
-    campaignId: t.Optional(t.String()),
-    identifier: t.Optional(t.String()),
-    creatorAddress: t.Optional(t.String()),
-    type: t.String(),
-    subType: t.Optional(t.Number()),
-    rewardTokenAddress: t.Optional(t.String()),
-    amount: t.Optional(t.String()),
-    opportunityIdentifier: t.Optional(t.String()),
-    startTimestamp: t.Optional(t.String()),
-    endTimestamp: t.Optional(t.String()),
-    params: t.Object({}),
-    tags: t.Optional(t.Array(t.String())),
-    chain: t.Optional(t.Object({})),
-    rewardToken: t.Optional(t.Object({})),
-    distributionChain: t.Optional(t.Object({})),
-    campaignStatus: t.Optional(t.Object({})),
-});
-export const FilledCampaignDto = t.Object({
-    id: t.String(),
-    distributionChainId: t.Number(),
-    rewardTokenId: t.String(),
-    opportunityId: t.String(),
-    computeChainId: t.Number(),
-    chainId: t.Number(),
-    campaignId: t.String(),
-    identifier: t.String(),
-    creatorAddress: t.String(),
-    type: t.String(),
-    subType: t.Optional(t.Number()),
-    rewardTokenAddress: t.String(),
-    amount: t.String(),
-    opportunityIdentifier: t.String(),
-    startTimestamp: t.String(),
-    endTimestamp: t.String(),
-    campaignParameters: t.Object({}),
-    mainParameter: t.String(),
-});

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

@@ -1,263 +0,0 @@
-import { campaignTVLBuilderFactory } from "@/engine/tvl/factory";
-import { HttpError } from "@/errors";
-import { InvalidParameter } from "@/errors/InvalidParameter.error";
-import { ComputedValueService } from "@/modules/v4//computedValue/computedValue.service";
-import { TokenService } from "@/modules/v4//token/token.service";
-import { AprService } from "@/modules/v4/apr/apr.service";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { OpportunityRepository } from "@/modules/v4/opportunity/opportunity.repository";
-import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
-import { RewardService } from "@/modules/v4/reward/reward.service";
-import { TvlService } from "@/modules/v4/tvl/tvl.service";
-import bigintToString from "@/utils/bigintToString";
-import { log } from "@/utils/logger";
-import { parseDistributionType } from "@/utils/parseDistributionType";
-import { AprType, DistributionType } from "@db/api";
-import { Campaign as CampaignType, ChainId, DAY, HOUR, NETWORK_LABELS, bigIntToNumber, } from "@sdk";
-import moment from "moment";
-export class DynamicDataService {
-    /**
-     * @notice Updates all records for opportunities associated to the given campaigns
-     *
-     * @dev The list must ONLY contain campaigns of the same type and the same computeChainId
-     */
-    static async checkValidUpdate(opportunityId, newApr) {
-        const previousRecords = await OpportunityRepository.findUnique(opportunityId);
-        const previousApr = previousRecords?.apr;
-        const lastUpdate = previousRecords?.AprRecords.reduce((acc, record) => Math.max(acc, Number(record.timestamp)), 0);
-        if (previousApr && lastUpdate && moment.now() / 1000 - lastUpdate < HOUR) {
-            if (newApr / previousApr < 0.5 || newApr / previousApr > 2)
-                return false;
-        }
-        return true;
-    }
-    static async update(chainId, type, campaigns, dryRun = false) {
-        // 1 - Safety check
-        for (const campaign of campaigns) {
-            if (campaign.computeChainId !== chainId || campaign.campaignType !== type) {
-                throw new InvalidParameter(`Campaign ${campaign.campaignId} is not of type ${type} on chain ${chainId}`);
-            }
-        }
-        const initialOpportunityIds = new Set(campaigns.map(c => OpportunityService.hashId({ chainId, identifier: c.mainParameter, type: CampaignType[+type] }))).size;
-        // 2 - If the new dynamic data builder is available, use it
-        if (!campaignTVLBuilderFactory(type)?.deprecated) {
-            const builder = campaignTVLBuilderFactory(type);
-            // 2.a - Call the builder
-            const records = await DynamicDataService.fetchWithRecursiveErrorHandling(builder.build, campaigns, chainId);
-            // 2.b - Regroup by opportunity and build records
-            const opportunityIds = new Set(records.map(r => OpportunityService.hashId({
-                chainId,
-                identifier: r.campaign.mainParameter,
-                type: CampaignType[+type],
-            })));
-            const now = moment().utc().unix();
-            const updates = [];
-            for (const opportunityId of opportunityIds) {
-                const recordsForOpportunity = records.filter(r => OpportunityService.hashId({
-                    chainId,
-                    identifier: r.campaign.mainParameter,
-                    type: CampaignType[+type],
-                }) === opportunityId);
-                const tvl = {
-                    timestamp: BigInt(now),
-                    total: 0,
-                    breakdowns: [],
-                };
-                const dailyRewards = {
-                    timestamp: BigInt(now),
-                    total: 0,
-                    breakdowns: [],
-                };
-                const apr = {
-                    timestamp: BigInt(now),
-                    cumulated: 0,
-                    breakdowns: [],
-                };
-                for (const record of recordsForOpportunity) {
-                    const { startTimestamp, endTimestamp, rewardToken: rewardTokenAddress, campaignParameters } = record.campaign;
-                    // 2.b.1 TVL of the opportunity is the max of all TVLs of the campaigns
-                    if (record.tvl > tvl.total) {
-                        tvl.total = record.tvl;
-                        tvl.breakdowns = record.tvlBreakdown;
-                    }
-                    if (!!record.displayTvl && record.displayTvl > tvl.total) {
-                        tvl.total = record.displayTvl;
-                    }
-                    try {
-                        // 2.b.2 Daily rewards is the sum of all daily rewards of the campaigns
-                        const timespan = endTimestamp - startTimestamp;
-                        const isWithinTimespan = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
-                        const dayspan = Math.max(1, timespan / DAY);
-                        let dailyAmount = isWithinTimespan
-                            ? (BigInt(record.campaign.amount) * BigInt(10 ** 6)) / BigInt(Math.floor(dayspan * 10 ** 6))
-                            : BigInt(0);
-                        let rewardToken;
-                        try {
-                            rewardToken = await TokenService.findUniqueOrThrow({
-                                address: rewardTokenAddress,
-                                chainId: record.campaign.chainId,
-                            });
-                        }
-                        catch {
-                            await TokenService.findManyOrCreate([{ address: rewardTokenAddress, chainId: record.campaign.chainId }]);
-                            rewardToken = await TokenService.findUniqueOrThrow({
-                                address: rewardTokenAddress,
-                                chainId: record.campaign.chainId,
-                            });
-                        }
-                        let campaignDailyValue = await TokenService.getValueByTokenId(TokenService.hashId({ address: rewardTokenAddress, chainId: record.campaign.chainId }), dailyAmount);
-                        // Fixed APR campaigns
-                        const distributionType = parseDistributionType(campaignParameters);
-                        if (distributionType !== DistributionType.DUTCH_AUCTION) {
-                            log.local(`[${NETWORK_LABELS[chainId]}][${CampaignType[type]}] calculating fixed APR for ${record.campaign.campaignId}`);
-                            const { apr: fixedApr } = campaignParameters;
-                            const targetApr = Number(fixedApr);
-                            if (distributionType === DistributionType.FIX_REWARD_VALUE_PER_LIQUIDITY_VALUE) {
-                                // Case 1: Fixed $ amount of reward per $ of liquidity
-                                campaignDailyValue = targetApr * tvl.total;
-                                dailyAmount = BigInt((campaignDailyValue / (rewardToken.price ?? 1)) * 10 ** rewardToken.decimals);
-                            }
-                            if (distributionType === DistributionType.FIX_REWARD_AMOUNT_PER_LIQUIDITY_VALUE) {
-                                // Return 0 if reward token price is invalid
-                                // targetApr represents a yearly # amount of reward per $ of liquidity
-                                dailyAmount =
-                                    (BigInt(Math.floor((targetApr * tvl.total * 10 ** 6) / 365)) * 10n ** BigInt(rewardToken.decimals)) /
-                                        10n ** 6n;
-                                campaignDailyValue = bigIntToNumber(dailyAmount, rewardToken.decimals) * (rewardToken.price ?? 1);
-                            }
-                        }
-                        dailyRewards.total += campaignDailyValue;
-                        if (campaignDailyValue > 0) {
-                            dailyRewards.breakdowns.push({
-                                campaignId: CampaignService.hashId({
-                                    campaignId: record.campaign.campaignId,
-                                    distributionChain: record.campaign.chainId,
-                                }),
-                                value: campaignDailyValue,
-                                amount: dailyAmount,
-                                token: rewardToken,
-                            });
-                        }
-                        // 2.b.3 APR is obtained from daily rewards and tvl following the distribution type
-                        let aprCampaignValue;
-                        if (rewardToken.isPoint) {
-                            aprCampaignValue = campaignDailyValue / record.tvl;
-                        }
-                        else {
-                            aprCampaignValue = (campaignDailyValue * 365 * 100) / record.tvl;
-                        }
-                        const lastEligibilityRatio = (await ComputedValueService.findCampaignValue(Bun.hash(`${record.campaign.chainId}${record.campaign.campaignId}`).toString(), "averageBoost"))?.averageBoost ?? 1;
-                        const forfeitingBoost = (await ComputedValueService.findCampaignValue(Bun.hash(`${record.campaign.chainId}${record.campaign.campaignId}`).toString(), "forfeitingBoost"))?.forfeitingBoost ?? 1;
-                        const averageAPIBoost = (await ComputedValueService.findCampaignValue(Bun.hash(`${record.campaign.chainId}${record.campaign.campaignId}`).toString(), "averageAPIBoost"))?.averageAPIBoost ?? 1;
-                        const computeMethodBoost = (await ComputedValueService.findCampaignValue(Bun.hash(`${record.campaign.chainId}${record.campaign.campaignId}`).toString(), "computeMethodBoost"))?.computeMethodBoost ?? 1;
-                        aprCampaignValue =
-                            aprCampaignValue * lastEligibilityRatio * forfeitingBoost * averageAPIBoost * computeMethodBoost;
-                        if (aprCampaignValue === Number.POSITIVE_INFINITY)
-                            aprCampaignValue = 10_001;
-                        if (aprCampaignValue > 0) {
-                            apr.cumulated += aprCampaignValue;
-                            apr.breakdowns.push({
-                                identifier: record.campaign.campaignId,
-                                type: AprType.CAMPAIGN,
-                                value: aprCampaignValue,
-                            });
-                        }
-                    }
-                    catch (_err) {
-                        log.error("failed to calculate daily rewards", _err);
-                    }
-                }
-                updates.push({
-                    opportunityId,
-                    tvl,
-                    apr,
-                    dailyRewards,
-                });
-            }
-            // 2.c - Update the records
-            if (!dryRun) {
-                for (const update of updates) {
-                    try {
-                        if (chainId !== ChainId.ETHERLINK ||
-                            (await DynamicDataService.checkValidUpdate(update.opportunityId, update.apr.cumulated))) {
-                            await OpportunityRepository.updateDynamicData(update.opportunityId, update.apr, update.tvl, update.dailyRewards);
-                        }
-                    }
-                    catch (err) {
-                        throw new HttpError("Failed to update dynamic data", 500, {
-                            err,
-                            chainId,
-                            type,
-                        });
-                    }
-                }
-                log.info(`[${NETWORK_LABELS[chainId]}][${CampaignType[type]}] updated ${updates.length}/${initialOpportunityIds} opportunities using campaignTVLBuilder`);
-            }
-            return updates;
-        }
-        const builder = campaignTVLBuilderFactory(type);
-        const dynamicDataArray = [];
-        const dynamicData = await DynamicDataService.fetchWithRecursiveErrorHandling(builder.build, campaigns, chainId);
-        const oppMap = {};
-        for (const data of dynamicData) {
-            if (!!data) {
-                // Main Parameter OVERRIDING
-                if (data.campaignType === CampaignType.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: CampaignType[+type],
-            });
-            try {
-                if (!dryRun)
-                    if (await DynamicDataService.checkValidUpdate(opportunityId, apr.cumulated)) {
-                        await OpportunityRepository.updateDynamicData(opportunityId, apr, tvl, dailyRewards);
-                    }
-            }
-            catch (err) {
-                log.error(`failed to update dynamic data for ${opportunityId}`, err);
-            }
-            dynamicDataArray.push(bigintToString({ campaignId: Object.values(entry[1])[0].campaignId, apr, tvl, dailyRewards }));
-        }
-        log.info(`[${NETWORK_LABELS[chainId]}][${CampaignType[type]}] updated ${dynamicData.length}/${campaigns.length} campaigns`);
-        return dynamicDataArray;
-    }
-    /**
-     * @dev Recursive function to handle errors in fetching dynamic data
-     */
-    static async fetchWithRecursiveErrorHandling(fn, campaigns, chainId) {
-        // Base case: empty input
-        if (campaigns.length === 0)
-            return [];
-        try {
-            return await fn(chainId, campaigns);
-        }
-        catch (error) {
-            // Base case: single failing campaign
-            if (campaigns.length === 1) {
-                log.error(`Permanent failure for campaign ${campaigns[0].campaignId}`, error);
-                return [];
-            }
-            // Recursive binary split
-            const mid = Math.ceil(campaigns.length / 2);
-            const [firstResults, secondResults] = await Promise.all([
-                // Process first half with error propagation
-                DynamicDataService.fetchWithRecursiveErrorHandling(fn, campaigns.slice(0, mid), chainId),
-                // Process second half with error propagation
-                DynamicDataService.fetchWithRecursiveErrorHandling(fn, campaigns.slice(mid), chainId),
-            ]);
-            return [...firstResults, ...secondResults];
-        }
-    }
-}

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

@@ -1,147 +0,0 @@
-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": "pancake-swap",
-    "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.js

@@ -1,116 +0,0 @@
-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 };
-            },
-        };
-    }
-}