@merkl/api 0.18.5 → 0.18.7

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

@@ -93,7 +93,11 @@ export const TokenController = new Elysia({ prefix: "/tokens", detail: { tags: [
     beforeHandle: BackOfficeGuard,
     detail: { hide: true },
 })
-    .get("/sync", async () => await TokenService.fillTokenAndIconsFromTokenList(), { 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), {
         body: NotionWebhookDto,

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

@@ -41,6 +41,7 @@ export declare const GetTokenQueryDto: import("@sinclair/typebox").TObject<{
     name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     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>;
 }>;
 export declare const TokenDto: import("@sinclair/typebox").TObject<{
     address: import("@sinclair/typebox").TString;

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

@@ -30,6 +30,7 @@ export const GetTokenQueryDto = t.Object({
     name: t.Optional(t.String()),
     verified: t.Optional(t.Boolean()),
     test: t.Optional(t.Boolean()),
+    missingIcons: t.Optional(t.Boolean()),
 });
 export const TokenDto = t.Object({
     address: t.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,35 +2,8 @@ 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 {
-    /**
-     * Fetch token metadata from onchain
-     * @param chainId
-     * @param address
-     * @returns
-     */
-    static async getTokenInfo(token) {
-        //TODO: replace with onchain module
-        const calls = getTokenInfo(token.address);
-        //TODO: replace with onchain module
-        return executeSimple(token.chainId, calls);
-    }
-    /**
-     * Read token from database
-     * @param chainId
-     * @param address
-     */
-    static async findUnique(id) {
-        return (await apiDbClient.token.findUnique({ where: { id } })) ?? undefined;
-    }
-    /**
-     * Read token from database
-     * @param chainId
-     * @param address
-     */
-    static async findUniqueOrThrow(id) {
-        return await apiDbClient.token.findUniqueOrThrow({ where: { id } });
-    }
     static #transformQueryToPrismaFilters(query) {
         const ids = query.id ? query.id.map(id => ({ id })) : [];
         return {
@@ -58,9 +31,38 @@ export class TokenRepository {
                 name: query.name ? { contains: query.name, mode: "insensitive" } : undefined,
                 verified: query.verified ? { equals: query.verified } : undefined,
                 isTest: query.test ? { equals: query.test } : undefined,
+                icon: query.missingIcons ? { equals: "" } : undefined,
             },
         };
     }
+    /**
+     * Fetch token metadata from onchain
+     * @param chainId
+     * @param address
+     * @returns
+     */
+    static async getTokenInfo(token) {
+        //TODO: replace with onchain module
+        const calls = getTokenInfo(token.address);
+        //TODO: replace with onchain module
+        return executeSimple(token.chainId, calls);
+    }
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static async findUnique(id) {
+        return (await apiDbClient.token.findUnique({ where: { id } })) ?? undefined;
+    }
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static async findUniqueOrThrow(id) {
+        return await apiDbClient.token.findUniqueOrThrow({ where: { id } });
+    }
     /**
      * Read token from database by its symbol
      * @param symbol
@@ -128,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;
@@ -54,6 +54,7 @@ export declare abstract class TokenService {
         balance: bigint;
     })[]>;
     static fetchOnChain(token: TokenModel): Promise<Omit<Token["model"], "id">>;
+    static tryToFillWithCoingeckoIcons(): Promise<void>;
     static fetchManyOnChain(chainId: ChainId, addresses: string[]): Promise<{
         [address: string]: Omit<{
             symbol: string;
@@ -91,49 +92,6 @@ export declare abstract class TokenService {
      * @param excludeAddresses to not update symbols that defined using addresses
      */
     static updatePrices(pricer: Pricer): Promise<void>;
-    /**
-     * Get all tokens from https://github.com/AngleProtocol/angle-token-list and override icons from it
-     * TODO: use the bucket
-     */
-    static fillTokenAndIconsFromTokenList(): 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
@@ -210,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;
@@ -254,4 +212,29 @@ export declare abstract class TokenService {
         isNative: boolean;
         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
+     */
+    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))
@@ -72,7 +72,6 @@ export class TokenService {
     }
     static async fetchOnChain(token) {
         const onchainData = await TokenRepository.getTokenInfo(token);
-        //TODO: find a way to get the icon
         return {
             chainId: token.chainId,
             address: token.address,
@@ -80,9 +79,36 @@ export class TokenService {
             ...Object.assign({ name: "unknown", decimals: 18, symbol: "UNKNOWN", verified: false, isTest: false, isNative: false }, onchainData),
         };
     }
+    static async tryToFillWithCoingeckoIcons() {
+        // 1 - Find coingecko price sources
+        let priceSources = await PriceService.findManyPriceSources({ method: "COINGECKO" });
+        // 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));
+        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 = {};
-        //Batch onchain calls together when multiples
+        // Batch onchain calls together when multiples
         for (const address of addresses) {
             tokens[address] = await TokenService.fetchOnChain({ chainId, address });
         }
@@ -128,101 +154,6 @@ export class TokenService {
             await TokenService.updateAddressPrices(address, price);
         }
     }
-    /**
-     * Get all tokens from https://github.com/AngleProtocol/angle-token-list and override icons from it
-     * TODO: use the bucket
-     */
-    static async fillTokenAndIconsFromTokenList() {
-        const tokenList = await getTokensListWithCache();
-        for (const chain of Object.keys(tokenList)) {
-            for (const [symbol, token] of Object.entries(tokenList[chain])) {
-                if (!(await TokenRepository.findUnique(TokenService.hashId({ chainId: Number.parseInt(chain), address: token.address })))) {
-                    try {
-                        const res = await TokenRepository.create({
-                            id: TokenService.hashId({ chainId: Number.parseInt(chain), address: token.address }),
-                            chainId: Number.parseInt(chain),
-                            address: token.address,
-                            name: token.name,
-                            symbol: token.symbol,
-                            verified: true,
-                            decimals: token.decimals,
-                            icon: token.logoURI,
-                            isTest: false,
-                            isNative: false,
-                        });
-                        log.local(`Token created: ${res?.symbol} on ${NETWORK_LABELS[Number.parseInt(chain)]}`);
-                    }
-                    catch (e) {
-                        console.error(e);
-                    }
-                }
-                try {
-                    await apiDbClient.token.update({
-                        data: {
-                            chainId: Number.parseInt(chain),
-                            address: token.address,
-                            name: token.name,
-                            symbol: token.symbol,
-                            verified: true,
-                            decimals: token.decimals,
-                            icon: token.logoURI,
-                        },
-                        where: {
-                            chainId_address: {
-                                chainId: Number.parseInt(chain),
-                                address: token.address,
-                            },
-                        },
-                    });
-                }
-                catch (e) {
-                    console.error(e);
-                }
-                try {
-                    const tokensWithSameSymbol = await apiDbClient.token.findMany({
-                        select: { chainId: true, address: true },
-                        where: { symbol: { equals: symbol, mode: "insensitive" } },
-                    });
-                    for (const dbToken of tokensWithSameSymbol) {
-                        await apiDbClient.token.update({
-                            data: { icon: token.logoURI },
-                            where: {
-                                chainId_address: {
-                                    chainId: dbToken.chainId,
-                                    address: dbToken.address,
-                                },
-                            },
-                        });
-                    }
-                }
-                catch (_err) { }
-            }
-        }
-    }
-    /**
-     * 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
@@ -252,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)
@@ -290,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 {
@@ -321,10 +252,6 @@ export class TokenService {
         }, chainId);
     }
     static async update(id, data) {
-        // let iconUri = data.icon;
-        // if (data.iconFile) {
-        //   iconUri = await BucketService.upload("merkl-assets", `/tokens/${id}`, data.iconFile.stream(), true);
-        // }
         return await TokenRepository.update(id, data);
     }
     static async notionWebhook(body) {
@@ -342,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,
@@ -381,4 +308,91 @@ export class TokenService {
             verified: isVerified,
         });
     }
+    /**
+     * 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
+     */
+    static async fillTokenAndIconsFromTokenList() {
+        const tokenList = await getTokensListWithCache();
+        for (const chain of Object.keys(tokenList)) {
+            for (const [symbol, token] of Object.entries(tokenList[chain])) {
+                if (!(await TokenRepository.findUnique(TokenService.hashId({ chainId: Number.parseInt(chain), address: token.address })))) {
+                    try {
+                        const res = await TokenRepository.create({
+                            id: TokenService.hashId({ chainId: Number.parseInt(chain), address: token.address }),
+                            chainId: Number.parseInt(chain),
+                            address: token.address,
+                            name: token.name,
+                            symbol: token.symbol,
+                            verified: true,
+                            decimals: token.decimals,
+                            icon: token.logoURI,
+                            isTest: false,
+                            isNative: false,
+                        });
+                        log.local(`Token created: ${res?.symbol} on ${NETWORK_LABELS[Number.parseInt(chain)]}`);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+                try {
+                    await apiDbClient.token.update({
+                        data: {
+                            chainId: Number.parseInt(chain),
+                            address: token.address,
+                            name: token.name,
+                            symbol: token.symbol,
+                            verified: true,
+                            decimals: token.decimals,
+                            icon: token.logoURI,
+                        },
+                        where: {
+                            chainId_address: {
+                                chainId: Number.parseInt(chain),
+                                address: token.address,
+                            },
+                        },
+                    });
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                try {
+                    const tokensWithSameSymbol = await apiDbClient.token.findMany({
+                        select: { chainId: true, address: true },
+                        where: { symbol: { equals: symbol, mode: "insensitive" } },
+                    });
+                    for (const dbToken of tokensWithSameSymbol) {
+                        await apiDbClient.token.update({
+                            data: { icon: token.logoURI },
+                            where: {
+                                chainId_address: {
+                                    chainId: dbToken.chainId,
+                                    address: dbToken.address,
+                                },
+                            },
+                        });
+                    }
+                }
+                catch (_err) { }
+            }
+        }
+    }
 }

package/dist/src/routes/v3/app.js

@@ -19,7 +19,7 @@ export default (app) => app.get("/app", async () => {
             if (!json.tokens[token.chainId]) {
                 json.tokens[token.chainId] = {};
             }
-            if (!json.tokens[token.chainId][token.address]) {
+            if (!json.tokens[token.chainId][token.address] && token.icon?.length > 0) {
                 json.tokens[token.chainId][token.address] = {
                     address: token.address,
                     chainId: token.chainId,

package/dist/src/utils/prices/priceService.js

@@ -26,7 +26,7 @@ export default class PriceService {
         });
     };
     async fetchPrices() {
-        const tokenPriceSources = await PriceSourceService.getManyPriceSources();
+        const tokenPriceSources = await PriceSourceService.findManyPriceSources();
         /**
          * @description Factory pricer's call to get prices from different sources
          */