@merkl/api 0.20.41 → 0.20.43

package/dist/src/eden/index.d.ts

@@ -1837,6 +1837,7 @@ declare const eden: {
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
@@ -1883,7 +1884,7 @@ declare const eden: {
                         isPoint: boolean;
                         isNative: boolean;
                         price: number | null;
-                    } | undefined;
+                    };
                 }>>;
             };
             count: {
@@ -1900,23 +1901,13 @@ declare const eden: {
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: number;
                 }>>;
             };
-            icons: {
-                post: (body: unknown, options: {
-                    headers: {
-                        authorization: string;
-                    };
-                    query?: Record<string, unknown> | undefined;
-                    fetch?: RequestInit | undefined;
-                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: void;
-                }>>;
-            };
             webhooks: {
                 notion: {
                     post: (body: {
@@ -5656,6 +5647,7 @@ declare const eden: {
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
@@ -5702,7 +5694,7 @@ declare const eden: {
                         isPoint: boolean;
                         isNative: boolean;
                         price: number | null;
-                    } | undefined;
+                    };
                 }>>;
             };
             count: {
@@ -5719,23 +5711,13 @@ declare const eden: {
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: number;
                 }>>;
             };
-            icons: {
-                post: (body: unknown, options: {
-                    headers: {
-                        authorization: string;
-                    };
-                    query?: Record<string, unknown> | undefined;
-                    fetch?: RequestInit | undefined;
-                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: void;
-                }>>;
-            };
             webhooks: {
                 notion: {
                     post: (body: {
@@ -10544,6 +10526,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     headers: unknown;
                     response: {
@@ -10581,6 +10564,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     headers: unknown;
                     response: {
@@ -10618,7 +10602,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             isPoint: boolean;
                             isNative: boolean;
                             price: number | null;
-                        } | undefined;
+                        };
                     };
                 };
             };
@@ -10659,20 +10643,6 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
-        } & {
-            icons: {
-                post: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: void;
-                    };
-                };
-            };
         } & {
             webhooks: {
                 notion: {
@@ -15881,6 +15851,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
@@ -15927,7 +15898,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         isPoint: boolean;
                         isNative: boolean;
                         price: number | null;
-                    } | undefined;
+                    };
                 }>>;
             };
             count: {
@@ -15944,23 +15915,13 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: number;
                 }>>;
             };
-            icons: {
-                post: (body: unknown, options: {
-                    headers: {
-                        authorization: string;
-                    };
-                    query?: Record<string, unknown> | undefined;
-                    fetch?: RequestInit | undefined;
-                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: void;
-                }>>;
-            };
             webhooks: {
                 notion: {
                     post: (body: {
@@ -19700,6 +19661,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
@@ -19746,7 +19708,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         isPoint: boolean;
                         isNative: boolean;
                         price: number | null;
-                    } | undefined;
+                    };
                 }>>;
             };
             count: {
@@ -19763,23 +19725,13 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: number;
                 }>>;
             };
-            icons: {
-                post: (body: unknown, options: {
-                    headers: {
-                        authorization: string;
-                    };
-                    query?: Record<string, unknown> | undefined;
-                    fetch?: RequestInit | undefined;
-                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: void;
-                }>>;
-            };
             webhooks: {
                 notion: {
                     post: (body: {

package/dist/src/engine/dynamicData/implementations/Erc20.js

@@ -9,7 +9,7 @@ import { TokenRepository } from "@/modules/v4/token/token.repository";
 import { TokenService } from "@/modules/v4/token/token.service";
 import { log } from "@/utils/logger";
 import { Pricer } from "@/utils/pricer";
-import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
+import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, ChainId, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
 export class Erc20DynamicData {
     async build(chainId, campaigns) {
         const pricer = await Pricer.load();
@@ -126,7 +126,7 @@ export class Erc20DynamicData {
                 log.warn(`failed to update target token price: ${e}`);
             }
             i += callsForCampaign;
-            const whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
+            let whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
             const totalSupplyTargetToken = whitelistedSupplyTargetToken;
             const priceTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
             let lastEligibilityRatio = 1;
@@ -158,6 +158,9 @@ export class Erc20DynamicData {
             ]);
             const rewardToken = rewardTokens[0];
             apr = rewardToken.isPoint ? apr / 365 / 100 : apr;
+            if (campaign.chainId === ChainId.ETHERLINK) {
+                whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply;
+            }
             dynamicData.push({
                 ...campaign,
                 apr,

package/dist/src/engine/dynamicData/implementations/EventBased.js

@@ -10,7 +10,7 @@ import { Pricer } from "../../../utils/pricer";
  * @dev important: using the most recent state save with current prices
  *      it's only an estimate
  */
-async function computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaignID, priceCurrency, decimalsCurrency) {
+async function computeEventBasedPoolRewardsFromMostRecentStateSave(chainId, campaignID, priceCurrency, decimalsCurrency) {
     let stateSave;
     let blockNumber;
     let states = {};
@@ -37,23 +37,22 @@ async function computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaign
     }
     const { fileName, bucketName } = states;
     // Bucket service
-    let tvl = 0;
+    let distributedRewards = 0;
     if (!fileName || !bucketName) {
-        return { tvl, blockNumber: blockNumber };
+        return { distributedRewards, blockNumber: blockNumber };
     }
     try {
         const bucket = new BucketService("merkl-production-states", "merkl-production");
         const storedStates = JSON.parse(await bucket.pull(fileName));
         for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
-            tvl += BN2Number(value.allTimeValue, 18 - decimalsCurrency);
+            distributedRewards += BN2Number(value.allTimeValue, 18);
         }
-        tvl = tvl * priceCurrency;
-        tvl = Math.max(tvl, 1);
+        distributedRewards = Math.max(distributedRewards, 1);
     }
     catch {
         log.warn(`merklDynamic data - failed to decode state of event based on ${NETWORK_LABELS[chainId]}`);
     }
-    return { tvl, blockNumber: blockNumber };
+    return { distributedRewards, blockNumber: blockNumber };
 }
 export class EventBasedDynamicData {
     async build(chainId, campaigns) {
@@ -67,7 +66,7 @@ export class EventBasedDynamicData {
                     chainId: chainId,
                     symbol: symbolCurrency0,
                 }));
-                const { tvl } = await computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaign.campaignId, priceToken, decimalsCurrency0);
+                const { distributedRewards } = await computeEventBasedPoolRewardsFromMostRecentStateSave(chainId, campaign.campaignId, priceToken, decimalsCurrency0);
                 const c = campaign;
                 const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
                 const multiplier = BN2Number(c.campaignParameters.topicToData[0].multiplier, 12 + 9);
@@ -76,11 +75,12 @@ export class EventBasedDynamicData {
                 const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
                 let distributionMeanAPR = 0;
                 const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                const tvl = distributedRewards / multiplier;
                 if (isLive) {
                     /** Yearly rewards in $ */
                     const fixRewardRate = multiplier * priceRewardToken;
                     distributionMeanAPR = fixRewardRate;
-                    if (tvl * fixRewardRate > (amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp)) {
+                    if (distributedRewards > (amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp)) {
                         distributionMeanAPR =
                             (fixRewardRate * amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp) / tvl;
                     }

package/dist/src/index.d.ts

@@ -2195,6 +2195,7 @@ declare const app: Elysia<"", false, {
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     headers: unknown;
                     response: {
@@ -2232,6 +2233,7 @@ declare const app: Elysia<"", false, {
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     headers: unknown;
                     response: {
@@ -2269,7 +2271,7 @@ declare const app: Elysia<"", false, {
                             isPoint: boolean;
                             isNative: boolean;
                             price: number | null;
-                        } | undefined;
+                        };
                     };
                 };
             };
@@ -2310,20 +2312,6 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
-        } & {
-            icons: {
-                post: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: void;
-                    };
-                };
-            };
         } & {
             webhooks: {
                 notion: {

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

@@ -279,9 +279,13 @@ export class CampaignService {
      */
     static format(campaign) {
         const { DistributionChain, ComputeChain, Creator, RewardToken, params, CampaignStatus, createdAt, manualOverrides: _, ...c } = campaign;
+        const updatedParams = params;
+        if (ComputeChain.name === "Etherlink") {
+            updatedParams.blacklist = [];
+        }
         return {
             ...c,
-            params: params,
+            params: updatedParams,
             chain: ComputeChain,
             endTimestamp: Number(c.endTimestamp),
             startTimestamp: Number(c.startTimestamp),

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

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

package/dist/src/modules/v4/coingecko/coingecko.repository.d.ts

@@ -0,0 +1,14 @@
+export declare class CoingeckoRepository {
+    static findList(): Promise<{
+        id: string;
+        symbol: string;
+        name: string;
+    }[]>;
+    static findMarkets(ids?: string[]): Promise<{
+        id: string;
+        symbol: string;
+        name: string;
+        image: string;
+        current_price: number;
+    }[]>;
+}

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

@@ -0,0 +1,9 @@
+import axios from "axios";
+export class CoingeckoRepository {
+    static async findList() {
+        return (await axios.get("https://api.coingecko.com/api/v3/coins/list")).data;
+    }
+    static async findMarkets(ids) {
+        return (await axios.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&per_page=250${!!ids ? `&ids=${ids.join(",")}` : ""}`)).data;
+    }
+}

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

@@ -0,0 +1,16 @@
+export declare class CoingeckoService {
+    static findList(): Promise<{
+        id: string;
+        symbol: string;
+        name: string;
+    }[]>;
+    static findMarkets(ids?: string[]): Promise<{
+        id: string;
+        symbol: string;
+        name: string;
+        image: string;
+        current_price: number;
+    }[]>;
+    static createPriceSourceForSymbolIfMissing(symbol: string, ticker: string): Promise<void>;
+    static fillTokensWithCoingeckoData(): Promise<void>;
+}

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

@@ -0,0 +1,65 @@
+import { CacheService } from "@/modules/v4/cache";
+import { PriceService } from "@/modules/v4/price/price.service";
+import { log } from "@/utils/logger";
+import { NETWORK_LABELS } from "@sdk";
+import { TTLPresets } from "../cache/cache.model";
+import { TokenService } from "../token/token.service";
+import { CoingeckoRepository } from "./coingecko.repository";
+export class CoingeckoService {
+    static findList() {
+        return CacheService.wrap(TTLPresets.HOUR_1, CoingeckoRepository.findList);
+    }
+    static findMarkets(ids) {
+        return CacheService.wrap(TTLPresets.MIN_5, CoingeckoRepository.findMarkets, ids);
+    }
+    static async createPriceSourceForSymbolIfMissing(symbol, ticker) {
+        try {
+            await PriceService.getPriceSourceBySymbol(symbol);
+        }
+        catch {
+            await PriceService.createPriceSource({
+                symbol: symbol,
+                method: "COINGECKO",
+                args: {
+                    ticker,
+                },
+            });
+            log.info(`added coingecko price source for token ${symbol}: ${ticker}`);
+        }
+    }
+    static async fillTokensWithCoingeckoData() {
+        // 1 - Get coingecko token list
+        const coingeckoData = CoingeckoService.findList();
+        // 2 - Find tokens with missing prices and try to add the sources
+        const missingPriceTokens = await TokenService.findMany({ missingPrice: true });
+        for (const token of missingPriceTokens) {
+            const coingeckoToken = (await coingeckoData).find(t => t.symbol === token.symbol && t.name === token.name);
+            if (!!coingeckoToken) {
+                await CoingeckoService.createPriceSourceForSymbolIfMissing(token.symbol, coingeckoToken.id);
+            }
+        }
+        // 3 - Find tokens with missing logos and gather their ids
+        const missingIconsTokens = await TokenService.findMany({ missingIcons: true });
+        const coingeckoIds = [];
+        for (const token of missingIconsTokens) {
+            const coingeckoToken = (await coingeckoData).find(t => t.symbol === token.symbol && t.name === token.name);
+            if (!!coingeckoToken) {
+                coingeckoIds.push(coingeckoToken.id);
+            }
+        }
+        // Avoid rate limits, wait 2 min
+        await new Promise(resolve => setTimeout(resolve, 120_000));
+        // 4 - Get images and fill them
+        const coingeckoMarkets = await CoingeckoService.findMarkets(coingeckoIds);
+        for (const market of coingeckoMarkets) {
+            for (const token of missingIconsTokens) {
+                if (token.symbol === market.symbol && token.name === market.name) {
+                    await TokenService.update(token.id, {
+                        icon: market.image,
+                    });
+                    log.info(`updated token ${token.symbol} on ${NETWORK_LABELS[token.chainId]} with icon ${market.image}`);
+                }
+            }
+        }
+    }
+}

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

@@ -16,7 +16,8 @@ export declare class ProgramPayloadService {
         safePayload: safePayload;
         nonEncodedConfig: any;
     }>;
-    static checkMinimumAmount(rewardToken: string, args: CampaignParametersStruct, distributionChainId: ChainId): Promise<boolean>;
+    static checkMinimumAmount(rewardToken: string, tokenAmount: bigint, numberOfHours: bigint, distributionChainId: ChainId): Promise<boolean>;
+    static getMinimumAmount(rewardToken: string, distributionChainId: ChainId): Promise<bigint>;
     static createSafePayloadForCampaign(args: CampaignParametersStruct, distributionChainId: ChainId, rewardToken: string, distributionCreator: string, withApproval?: boolean): Promise<[approvalTransaction, createCampaignTransaction] | [createCampaignTransaction]>;
     static initiateSafePayload(distributionChainId: ChainId, distributionCreator: string, rewardToken: string, approvalAmount?: string): safePayload;
     static buildPayload(query: CampaignPayloadInputModel, initialCampaignPayload?: safePayload | null, totalAmount?: string): Promise<safePayload>;

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

@@ -71,6 +71,11 @@ export class ProgramPayloadService {
         // Small hack to avoid the need to parse the config again
         const args = buildCampaignPayload(parsedConfig, distributionChainId).args;
         const safePayload = ProgramPayloadService.initiateSafePayload(distributionChainId, distributionCreator, rewardToken);
+        const tokenAmount = BigInt(args?.amount.toString());
+        const numberOfHours = BigInt(args?.duration.toString()) / 3600n;
+        if (!(await ProgramPayloadService.checkMinimumAmount(rewardToken, tokenAmount, numberOfHours, distributionChainId))) {
+            throw new Error("Amount is less than minimum");
+        }
         const transactions = await ProgramPayloadService.createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator ?? NULL_ADDRESS);
         safePayload.transactions.push(...transactions);
         if (debug) {
@@ -78,23 +83,25 @@ export class ProgramPayloadService {
         }
         return safePayload;
     }
-    static async checkMinimumAmount(rewardToken, args, distributionChainId) {
+    static async checkMinimumAmount(rewardToken, tokenAmount, numberOfHours, distributionChainId) {
+        const minimumAmountPerHour = await ProgramPayloadService.getMinimumAmount(rewardToken, distributionChainId);
+        if (!minimumAmountPerHour) {
+            throw new Error("Token not found");
+        }
+        return tokenAmount / numberOfHours >= BigInt(minimumAmountPerHour);
+    }
+    static async getMinimumAmount(rewardToken, distributionChainId) {
         const tokenList = await TokenService.getValidRewardTokens(distributionChainId);
         const minimumAmountPerHour = tokenList.find(token => token.address.toLowerCase() === rewardToken.toLowerCase())?.minimumAmountPerHour;
         if (!minimumAmountPerHour) {
             throw new Error("Token not found");
         }
-        const tokenAmount = BigInt(args?.amount.toString());
-        const numberOfHours = BigInt(args?.duration.toString()) / 3600n;
-        return tokenAmount / numberOfHours >= BigInt(minimumAmountPerHour);
+        return BigInt(minimumAmountPerHour);
     }
     static async createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator, withApproval = true) {
         const safePayload = _.cloneDeep(safeTemplate);
         safePayload.chainId = distributionChainId.toString();
         safePayload.createdAt = Math.floor(Date.now() / 1000);
-        if (!(await ProgramPayloadService.checkMinimumAmount(rewardToken, args, distributionChainId))) {
-            throw new Error("Amount is less than minimum");
-        }
         safePayload.transactions[0].to = rewardToken;
         safePayload.transactions[0].contractInputsValues = {
             amount: args?.amount.toString(),
@@ -180,9 +187,16 @@ export class ProgramPayloadService {
     static async buildProgramPayloadWithAmounts(query, body) {
         let campaignPayloads = null;
         const totalAmount = Object.values(body).reduce((sum, amount) => sum + BigInt(amount), 0n);
+        const minimumAmountPerHour = await ProgramPayloadService.getMinimumAmount(query.rewardToken, query.distributionChainId);
+        const numberOfHours = (BigInt(query.endTimestamp) - BigInt(query.startTimestamp)) / 3600n;
+        if (!minimumAmountPerHour) {
+            throw new Error("Token not found");
+        }
         for (const [campaign, amount] of Object.entries(body)) {
             if (Object.keys(MerklInterfaceCampaigns[query.program]).includes(campaign)) {
                 const queryCampaign = { ...query, campaign, amount: amount };
+                if (BigInt(amount) / numberOfHours < BigInt(minimumAmountPerHour))
+                    throw new Error("Amount is less than minimum");
                 campaignPayloads = await ProgramPayloadService.buildPayload(queryCampaign, campaignPayloads, totalAmount.toString());
             }
             else {

package/dist/src/modules/v4/router.d.ts

@@ -2065,6 +2065,7 @@ export declare const v4: Elysia<"/v4", false, {
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     headers: unknown;
                     response: {
@@ -2102,6 +2103,7 @@ export declare const v4: Elysia<"/v4", false, {
                         isNative?: boolean | undefined;
                         test?: boolean | undefined;
                         missingIcons?: boolean | undefined;
+                        missingPrice?: boolean | undefined;
                     };
                     headers: unknown;
                     response: {
@@ -2139,7 +2141,7 @@ export declare const v4: Elysia<"/v4", false, {
                             isPoint: boolean;
                             isNative: boolean;
                             price: number | null;
-                        } | undefined;
+                        };
                     };
                 };
             };
@@ -2180,20 +2182,6 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
-        } & {
-            icons: {
-                post: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: void;
-                    };
-                };
-            };
         } & {
             webhooks: {
                 notion: {

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

@@ -156,6 +156,7 @@ export declare const TokenController: Elysia<"/tokens", false, {
                     isNative?: boolean | undefined;
                     test?: boolean | undefined;
                     missingIcons?: boolean | undefined;
+                    missingPrice?: boolean | undefined;
                 };
                 headers: unknown;
                 response: {
@@ -193,6 +194,7 @@ export declare const TokenController: Elysia<"/tokens", false, {
                     isNative?: boolean | undefined;
                     test?: boolean | undefined;
                     missingIcons?: boolean | undefined;
+                    missingPrice?: boolean | undefined;
                 };
                 headers: unknown;
                 response: {
@@ -230,7 +232,7 @@ export declare const TokenController: Elysia<"/tokens", false, {
                         isPoint: boolean;
                         isNative: boolean;
                         price: number | null;
-                    } | undefined;
+                    };
                 };
             };
         };
@@ -271,20 +273,6 @@ export declare const TokenController: Elysia<"/tokens", false, {
                 };
             };
         };
-    } & {
-        icons: {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: {
-                    authorization: string;
-                };
-                response: {
-                    200: void;
-                };
-            };
-        };
     } & {
         webhooks: {
             notion: {

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

@@ -92,11 +92,6 @@ export const TokenController = new Elysia({ prefix: "/tokens", detail: { tags: [
     headers: AuthorizationHeadersDto,
     beforeHandle: BackOfficeGuard,
     detail: { hide: true },
-})
-    .post("/icons", async () => await TokenService.tryToFillWithCoingeckoIcons(), {
-    headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
-    detail: { hide: true },
 })
     .group("/webhooks", app => {
     return app.post("/notion", async ({ body }) => TokenService.notionWebhook(body), {

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

@@ -42,6 +42,7 @@ export declare const GetTokenQueryDto: import("@sinclair/typebox").TObject<{
     verified: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     test: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     missingIcons: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    missingPrice: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
 }>;
 export declare const TokenDto: import("@sinclair/typebox").TObject<{
     address: import("@sinclair/typebox").TString;