@merkl/api 0.18.6 → 0.18.7

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

@@ -616,13 +616,6 @@ declare const eden: {
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;
@@ -4075,13 +4068,6 @@ declare const eden: {
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;
@@ -8000,13 +7986,6 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 price?: number | null | undefined;
                             })[];
                             chain: {
-                                Explorer: {
-                                    id: string;
-                                    type: import("@db/api").$Enums.ExplorerType;
-                                    url: string;
-                                    chainId: number;
-                                }[];
-                            } & {
                                 id: number;
                                 name: string;
                                 icon: string;
@@ -13291,13 +13270,6 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;
@@ -16750,13 +16722,6 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;

package/dist/src/factories/opportunityMetadata/implementations/Ajna.js

@@ -3,7 +3,7 @@ import { OpportunityAction } from "@db/api";
 export class AjnaMetadata {
     async build(computeChainId, params, subType) {
         try {
-            const [collateral, quote] = await TokenService.getManyOrCreate([
+            const [collateral, quote] = await TokenService.findManyOrCreate([
                 {
                     chainId: computeChainId,
                     address: params.collateralToken,

package/dist/src/factories/opportunityMetadata/implementations/Badger.js

@@ -3,7 +3,7 @@ import { OpportunityAction } from "@db/api";
 export class BadgerMetadata {
     async build(computeChainId, params) {
         try {
-            const [token] = await TokenService.getManyOrCreate([{ chainId: computeChainId, address: params.targetToken }]);
+            const [token] = await TokenService.findManyOrCreate([{ chainId: computeChainId, address: params.targetToken }]);
             if (!token)
                 throw new Error("Failed to fetch tokens");
             return {

package/dist/src/index.d.ts

@@ -408,13 +408,6 @@ declare const app: Elysia<"", false, {
                                 price?: number | null | undefined;
                             })[];
                             chain: {
-                                Explorer: {
-                                    id: string;
-                                    type: import("@db/api").$Enums.ExplorerType;
-                                    url: string;
-                                    chainId: number;
-                                }[];
-                            } & {
                                 id: number;
                                 name: string;
                                 icon: string;

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

@@ -183,7 +183,7 @@ export class CampaignRepository {
     static async upsert(campaign) {
         const campaignType = CampaignService.getTypeFromV3(campaign.type);
         try {
-            const [rewardToken] = await TokenService.getManyOrCreate([
+            const [rewardToken] = await TokenService.findManyOrCreate([
                 { chainId: campaign.chainId, address: campaign.rewardTokenAddress },
             ]);
             if (!rewardToken) {

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

@@ -51,8 +51,8 @@ export class EnsoService {
         return await Promise.all(route.map(async (r) => {
             switch (r.action) {
                 case "deposit": {
-                    const tokensIn = await TokenService.getManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
-                    const [tokenOut] = await TokenService.getManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
+                    const tokensIn = await TokenService.findManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
+                    const [tokenOut] = await TokenService.findManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
                     return {
                         action: "deposit",
                         tokens: tokensIn.filter(a => !!a),
@@ -60,8 +60,8 @@ export class EnsoService {
                     };
                 }
                 case "swap": {
-                    const [from] = await TokenService.getManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
-                    const [to] = await TokenService.getManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
+                    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 };
                 }
             }
@@ -106,7 +106,7 @@ export class EnsoService {
                     amountIn: [fromTokenAmount.toString()],
                     slippage: options.slippage?.toString(),
                 });
-                const [LpToken] = await TokenService.getManyOrCreate([{ address: identifier, chainId }]);
+                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/kyberzap/kyberzap.service.js

@@ -54,7 +54,7 @@ export class KyberZapService {
         const actions = [];
         const processors = {
             ACTION_TYPE_PROTOCOL_FEE: async ({ protocolFee: { tokens: zapTokens } }) => {
-                const tokens = await TokenService.getManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
+                const tokens = await TokenService.findManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
                 return [
                     {
                         action: "fee",
@@ -65,7 +65,7 @@ export class KyberZapService {
             ACTION_TYPE_AGGREGATOR_SWAP: async ({ aggregatorSwap: { swaps } }) => {
                 const swapActions = [];
                 for (const { tokenIn, tokenOut } of swaps) {
-                    const [from, to] = await TokenService.getManyOrCreate([
+                    const [from, to] = await TokenService.findManyOrCreate([
                         { address: tokenIn.address, chainId },
                         { address: tokenOut.address, chainId },
                     ]);
@@ -80,7 +80,7 @@ export class KyberZapService {
             ACTION_TYPE_POOL_SWAP: async ({ poolSwap: { swaps } }) => {
                 const swapActions = [];
                 for (const { tokenIn, tokenOut } of swaps) {
-                    const [from, to] = await TokenService.getManyOrCreate([
+                    const [from, to] = await TokenService.findManyOrCreate([
                         { address: tokenIn.address, chainId },
                         { address: tokenOut.address, chainId },
                     ]);
@@ -93,7 +93,7 @@ export class KyberZapService {
                 return swapActions;
             },
             ACTION_TYPE_ADD_LIQUIDITY: async ({ addLiquidity: { tokens: zapTokens } }) => {
-                const tokens = await TokenService.getManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
+                const tokens = await TokenService.findManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
                 return [
                     {
                         action: "deposit",
@@ -124,7 +124,7 @@ export class KyberZapService {
             chainId,
         });
         const actions = await KyberZapService.getActions(chainId, route.zapDetails.actions);
-        const [tokenIn] = await TokenService.getManyOrCreate([{ address: fromTokenAddress, chainId }]);
+        const [tokenIn] = await TokenService.findManyOrCreate([{ address: fromTokenAddress, chainId }]);
         const deposit = actions.findLast(({ action }) => action === "deposit");
         const tokenInValue = await TokenService.getValue([{ ...tokenIn, amount: fromTokenAmount }]);
         const depositValue = await TokenService.getValue(deposit.tokens);

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

@@ -263,13 +263,6 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;

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

@@ -175,13 +175,6 @@ export declare abstract class OpportunityRepository {
     }) | null>;
     static findUniqueOrThrow(id: string, withTest?: boolean, withCampaigns?: boolean): Promise<{
         Chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;

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

@@ -551,13 +551,6 @@ export declare abstract class OpportunityService {
             price?: number | null | undefined;
         })[];
         chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;
@@ -723,13 +716,6 @@ export declare abstract class OpportunityService {
             price?: number | null | undefined;
         })[];
         chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;
@@ -891,13 +877,6 @@ export declare abstract class OpportunityService {
             price?: number | null | undefined;
         })[];
         chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;
@@ -938,13 +917,6 @@ export declare abstract class OpportunityService {
             price?: number | null | undefined;
         })[];
         chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;

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

@@ -69,7 +69,7 @@ export class OpportunityService {
             identifier: campaign.opportunityIdentifier,
             type: campaignType,
         });
-        const tokens = (await TokenService.getManyOrCreate(metadata.tokens)).filter(t => t !== undefined);
+        const tokens = (await TokenService.findManyOrCreate(metadata.tokens)).filter(t => t !== undefined);
         const params = JSON.parse(campaign.params);
         const now = moment().unix();
         const opportunity = {

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

@@ -6,7 +6,7 @@ export class PriceRepository {
     static async findManyPriceSources(query) {
         return await apiDbClient.priceSource.findMany({
             where: {
-                method: query.method ?? undefined,
+                method: query?.method ?? undefined,
             },
         });
     }

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

@@ -321,7 +321,7 @@ export class RewardService {
                     token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
                 }
                 catch {
-                    await TokenService.create(await TokenService.fetchOnChain({ address: rewardToken, chainId }));
+                    await TokenService.findManyOrCreate([{ address: rewardToken, chainId }]);
                     token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
                 }
                 const campaignDailyValue = await TokenService.getValueByTokenId(tokenToAmount);

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

@@ -278,13 +278,6 @@ export declare const v4: Elysia<"/v4", false, {
                                 price?: number | null | undefined;
                             })[];
                             chain: {
-                                Explorer: {
-                                    id: string;
-                                    type: import("@db/api").$Enums.ExplorerType;
-                                    url: string;
-                                    chainId: number;
-                                }[];
-                            } & {
                                 id: number;
                                 name: string;
                                 icon: string;

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

@@ -77,6 +77,8 @@ export declare abstract class TokenRepository {
      * @param chainId
      */
     static updateAddressPrices(address: string, price: number, chainId?: number): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    static updateMissingIconsPerSymbol(symbol: string, icon: string): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    static fetchIconFromCoingeckoTicker(coingeckoTicker: string): Promise<any>;
     static findChains(): Promise<Record<string, ChainId>>;
     /**
      * create a token on database

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

@@ -2,6 +2,7 @@ import { getTokenInfo } from "@/libs/tokens/tokenInfo";
 import { executeSimple } from "@/utils/execute";
 import { apiDbClient } from "@/utils/prisma";
 import { NETWORK_LABELS } from "@sdk";
+import axios from "axios";
 export class TokenRepository {
     static #transformQueryToPrismaFilters(query) {
         const ids = query.id ? query.id.map(id => ({ id })) : [];
@@ -129,6 +130,18 @@ export class TokenRepository {
             },
         });
     }
+    static async updateMissingIconsPerSymbol(symbol, icon) {
+        return await apiDbClient.token.updateMany({
+            data: { icon },
+            where: {
+                symbol: symbol,
+                icon: "",
+            },
+        });
+    }
+    static async fetchIconFromCoingeckoTicker(coingeckoTicker) {
+        return (await axios.get(`https://api.coingecko.com/api/v3/coins/${coingeckoTicker}`)).data.image.small;
+    }
     static async findChains() {
         const tokens = await apiDbClient.token.findMany({
             select: { chainId: true, id: true },

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type ChainId } from "@sdk";
-import type { NotionWebhookModel } from "./token.model";
-import type { CreateTokenModel, GetTokenQueryModel, Token, TokenModel, TokenUnique, UpdateTokenModel } from "./token.model";
+import type { CreateTokenModel, NotionWebhookModel } from "./token.model";
+import type { GetTokenQueryModel, Token, TokenModel, TokenUnique, UpdateTokenModel } from "./token.model";
 import { TokenRepository } from "./token.repository";
 export declare abstract class TokenService {
     static hashId(token: TokenUnique): string;
@@ -92,44 +92,6 @@ export declare abstract class TokenService {
      * @param excludeAddresses to not update symbols that defined using addresses
      */
     static updatePrices(pricer: Pricer): Promise<void>;
-    /**
-     * Create token on database
-     * @param chainId
-     * @param address
-     */
-    static create(token: Omit<Token["model"], "id">): Promise<({
-        symbol: string;
-        id: string;
-        name: string | null;
-        icon: string;
-        chainId: number;
-        address: string;
-        decimals: number;
-        verified: boolean;
-        isTest: boolean;
-        isNative: boolean;
-    } & {
-        price?: number | null | undefined;
-    }) | undefined>;
-    /**
-     * Fetches symbol, address, decimals and creates token on database
-     * @param chainId
-     * @param address
-     */
-    static fillAndCreate(token: CreateTokenModel): Promise<({
-        symbol: string;
-        id: string;
-        name: string | null;
-        icon: string;
-        chainId: number;
-        address: string;
-        decimals: number;
-        verified: boolean;
-        isTest: boolean;
-        isNative: boolean;
-    } & {
-        price?: number | null | undefined;
-    }) | undefined>;
     /**
      * Read token from database
      * @param chainId
@@ -206,7 +168,7 @@ export declare abstract class TokenService {
      * @param chainId
      * @param address
      */
-    static getManyOrCreate(tokens: TokenModel[]): Promise<(Token["model"] | undefined)[]>;
+    static findManyOrCreate(tokens: TokenModel[]): Promise<(Token["model"] | undefined)[]>;
     static getValidRewardTokens(chainId: number): Promise<{
         minimumAmountPerHour: any;
         symbol: string;
@@ -251,9 +213,28 @@ export declare abstract class TokenService {
         price: number | null;
     }>;
     /**
+     * Fetches symbol, address, decimals and creates token on database
+     * @param chainId
+     * @param address
+     */
+    static fillAndCreate(token: CreateTokenModel): Promise<({
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        chainId: number;
+        address: string;
+        decimals: number;
+        verified: boolean;
+        isTest: boolean;
+        isNative: boolean;
+    } & {
+        price?: number | null | undefined;
+    }) | undefined>;
+    /**
+     * @deprecated Should be useless now that the token list is not used anymore
      * Get all tokens from https://github.com/AngleProtocol/angle-token-list and override icons from it
      * TODO: use the bucket
-     * @deprecated Should be useless now that the token list is not used anymore
      */
     static fillTokenAndIconsFromTokenList(): Promise<void>;
 }

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

@@ -51,7 +51,7 @@ export class TokenService {
      * Fetches tokens and include balances
      */
     static async fetchTokensAndBalances(chainId, userAddress, addresses) {
-        const tokens = await TokenService.getManyOrCreate(addresses?.map(address => ({ chainId, address })));
+        const tokens = await TokenService.findManyOrCreate(addresses?.map(address => ({ chainId, address })));
         return TokenService.fetchBalances(chainId, userAddress, tokens.filter(t => t !== undefined));
     }
     /**
@@ -63,7 +63,7 @@ export class TokenService {
         const verifiedTokens = await TokenService.findMany({ chainId: chainId, verified: true });
         const nativeTokens = await TokenService.findMany({ chainId: chainId, isNative: true });
         const additionalTokens = !!additionalTokenAddresses?.length
-            ? await TokenService.getManyOrCreate(additionalTokenAddresses?.map(address => ({ chainId, address })))
+            ? await TokenService.findManyOrCreate(additionalTokenAddresses?.map(address => ({ chainId, address })))
             : [];
         const allTokens = verifiedTokens
             .concat(additionalTokens.filter(t => t !== undefined))
@@ -85,9 +85,26 @@ export class TokenService {
         // 2 - Find tokens with missing logos
         const missingIcons = await TokenService.findMany({ missingIcons: true });
         // 3 - Do the intersection of both
-        priceSources = priceSources.filter(p => missingIcons.find(t => t.symbol === p.symbol || t.address === p.symbol));
+        priceSources = priceSources.filter(p => !!missingIcons.find(t => t.symbol === p.symbol));
         log.info(`found ${priceSources.length} tokens with missing icons on coingecko.`);
         // 4 - Loop through each and try to get the icon
+        for (const priceSource of priceSources) {
+            const coingeckoTicker = priceSource.args?.ticker;
+            if (!!coingeckoTicker) {
+                try {
+                    const icon = await TokenRepository.fetchIconFromCoingeckoTicker(coingeckoTicker);
+                    if (icon.length > 0) {
+                        const res = await TokenRepository.updateMissingIconsPerSymbol(priceSource.symbol, icon);
+                        log.info(`updated ${res.count} tokens with icon ${icon} ${priceSource.symbol}`);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                // Avoid rate limits, wait 1 min
+                await new Promise(resolve => setTimeout(resolve, 60_000));
+            }
+        }
     }
     static async fetchManyOnChain(chainId, addresses) {
         const tokens = {};
@@ -137,30 +154,6 @@ export class TokenService {
             await TokenService.updateAddressPrices(address, price);
         }
     }
-    /**
-     * Create token on database
-     * @param chainId
-     * @param address
-     */
-    static async create(token) {
-        const id = TokenService.hashId(token);
-        return TokenRepository.upsert({ ...token, id });
-    }
-    /**
-     * Fetches symbol, address, decimals and creates token on database
-     * @param chainId
-     * @param address
-     */
-    static async fillAndCreate(token) {
-        try {
-            const id = TokenService.hashId(token);
-            const filledData = await TokenService.fetchOnChain({ address: token.address, chainId: token.chainId });
-            return await TokenRepository.upsert({ ...filledData, ...token, id });
-        }
-        catch (e) {
-            console.error(e);
-        }
-    }
     /**
      * Read token from database
      * @param chainId
@@ -190,7 +183,7 @@ export class TokenService {
      * @returns the cumulated dollar value of all tokens
      */
     static async getValue(tokenAmounts) {
-        const tokens = await TokenService.getManyOrCreate(tokenAmounts.map(({ address, chainId }) => ({ address, chainId })));
+        const tokens = await TokenService.findManyOrCreate(tokenAmounts.map(({ address, chainId }) => ({ address, chainId })));
         return tokenAmounts.reduce((sum, { amount, address, chainId }) => {
             const token = tokens
                 .filter(t => t !== undefined)
@@ -228,7 +221,7 @@ export class TokenService {
      * @param chainId
      * @param address
      */
-    static async getManyOrCreate(tokens) {
+    static async findManyOrCreate(tokens) {
         return await Promise.all(tokens.map(async (token) => {
             const id = TokenService.hashId(token);
             try {
@@ -276,7 +269,7 @@ export class TokenService {
         const isVerified = properties.Verified.checkbox;
         const coingeckoApiId = properties["CoinGecko API ID"].rich_text[0].plain_text;
         const byteArray = await iconFile.bytes();
-        const [token] = await TokenService.getManyOrCreate([
+        const [token] = await TokenService.findManyOrCreate([
             {
                 chainId,
                 address,
@@ -316,9 +309,24 @@ export class TokenService {
         });
     }
     /**
+     * Fetches symbol, address, decimals and creates token on database
+     * @param chainId
+     * @param address
+     */
+    static async fillAndCreate(token) {
+        try {
+            const id = TokenService.hashId(token);
+            const filledData = await TokenService.fetchOnChain({ address: token.address, chainId: token.chainId });
+            return await TokenRepository.upsert({ ...filledData, ...token, id });
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    /**
+     * @deprecated Should be useless now that the token list is not used anymore
      * Get all tokens from https://github.com/AngleProtocol/angle-token-list and override icons from it
      * TODO: use the bucket
-     * @deprecated Should be useless now that the token list is not used anymore
      */
     static async fillTokenAndIconsFromTokenList() {
         const tokenList = await getTokensListWithCache();