@merkl/api 0.18.4 → 0.18.6

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

@@ -3,6 +3,7 @@ import { getTokensListWithCache } from "@/libs/getTokensList";
 import { getOnlyUserBalance } from "@/libs/tokens/balances";
 import { log } from "@/utils/logger";
 import { apiDbClient } from "@/utils/prisma";
+import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
 import { Prisma } from "@db/api";
 import { ChainInteractionService, DistributionCreatorService, NETWORK_LABELS, bigIntToNumber, } from "@sdk";
 import { getAddress, parseUnits } from "viem";
@@ -71,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,
@@ -79,9 +79,19 @@ 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 || t.address === p.symbol));
+        log.info(`found ${priceSources.length} tokens with missing icons on coingecko.`);
+        // 4 - Loop through each and try to get the icon
+    }
     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 });
         }
@@ -127,77 +137,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
@@ -320,24 +259,21 @@ 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) {
         const env = process.env.ENV === "prod" ? "production" : process.env.ENV;
         const bucket = new BucketService(`merkl-${env}-tokens`, `angle-${env}-1`);
         const properties = body.data.properties;
-        const icon = properties["Icon"].files?.[0]?.file.url;
+        const icon = properties.Icon.files?.[0]?.file.url;
         const iconFile = await fetch(icon);
         const mimeType = iconFile.headers.get("content-type");
         const extension = mimeType.split("/")[1];
-        const address = properties["Address"].rich_text[0].plain_text;
+        const address = throwOnInvalidRequiredAddress(properties.Address.rich_text[0].plain_text);
         const chainId = properties["Chain ID"].number;
-        const symbol = properties["Symbol"].rich_text[0]?.plain_text;
-        const isVerified = properties["Verified"].checkbox;
+        throwOnUnsupportedChainId(chainId);
+        const displaySymbol = properties.Symbol.rich_text[0]?.plain_text;
+        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([
@@ -347,7 +283,7 @@ export class TokenService {
             },
         ]);
         if (!token || !token.name)
-            throw new HttpError(`Failed to fetch on-chain data for token ${symbol} (${address} on chainId ${chainId}).`);
+            throw new HttpError(`Failed to fetch on-chain data for token ${token?.symbol} (${address} on chainId ${chainId}).`);
         try {
             await bucket.pushRaw(`${chainId}/${address}.${extension}`, byteArray, {
                 type: mimeType,
@@ -361,7 +297,11 @@ export class TokenService {
         }
         if (coingeckoApiId) {
             try {
-                await PriceService.createPriceSource({ method: "COINGECKO", symbol, args: { ticker: coingeckoApiId } });
+                await PriceService.createPriceSource({
+                    method: "COINGECKO",
+                    symbol: token.symbol,
+                    args: { ticker: coingeckoApiId },
+                });
             }
             catch (err) {
                 console.error("Failed to create price source.");
@@ -370,9 +310,81 @@ export class TokenService {
         }
         return await TokenService.update(token.id, {
             icon: token.icon,
-            displaySymbol: symbol && symbol !== "" ? symbol : token.symbol,
+            displaySymbol: displaySymbol && displaySymbol !== "" ? displaySymbol : token.symbol,
             name: token.name,
             verified: isVerified,
         });
     }
+    /**
+     * 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();
+        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
          */