@merkl/api 0.20.102 → 0.20.104

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

@@ -4,33 +4,55 @@ import axios from "axios";
 export class TokenRepository {
     static #transformQueryToPrismaFilters(query) {
         const ids = query.id ? query.id.map(id => ({ id })) : [];
+        const { page: _page, items: _items } = query;
+        const page = _page ? _page : 0;
+        const items = _items !== undefined ? _items : 100;
         return {
+            take: items === 0 ? undefined : items,
+            skip: page * items,
             where: {
-                OR: query.symbol
-                    ? [
-                        { symbol: { equals: query.symbol, mode: "insensitive" } },
-                        { displaySymbol: { equals: query.symbol, mode: "insensitive" } },
-                        ...ids,
-                    ]
-                    : query.displaySymbol
-                        ? [
-                            {
-                                displaySymbol: "",
-                                symbol: { equals: query.displaySymbol, mode: "insensitive" },
-                            },
-                            { displaySymbol: { equals: query.displaySymbol, mode: "insensitive" } },
-                            ...ids,
-                        ]
-                        : ids.length
-                            ? [...ids]
-                            : undefined,
-                address: query.address ? { equals: query.address, mode: "insensitive" } : undefined,
-                chainId: query.chainId ? { equals: query.chainId } : undefined,
-                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,
-                price: query.missingPrice ? { equals: null } : undefined,
+                AND: [
+                    {
+                        OR: query.symbol
+                            ? [
+                                { symbol: { equals: query.symbol, mode: "insensitive" } },
+                                { displaySymbol: { equals: query.symbol, mode: "insensitive" } },
+                                ...ids,
+                            ]
+                            : query.displaySymbol
+                                ? [
+                                    {
+                                        displaySymbol: "",
+                                        symbol: { equals: query.displaySymbol, mode: "insensitive" },
+                                    },
+                                    { displaySymbol: { equals: query.displaySymbol, mode: "insensitive" } },
+                                    ...ids,
+                                ]
+                                : ids.length
+                                    ? [...ids]
+                                    : undefined,
+                        address: query.address ? { equals: query.address, mode: "insensitive" } : undefined,
+                        chainId: query.chainId ? { equals: query.chainId } : undefined,
+                        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,
+                        price: query.missingPrice ? { equals: null } : undefined,
+                    },
+                    !query.search
+                        ? {}
+                        : {
+                            AND: query.search?.split(" ")?.map((keyword) => ({
+                                OR: [
+                                    { id: { contains: keyword, mode: "insensitive" } },
+                                    { name: { contains: keyword, mode: "insensitive" } },
+                                    { symbol: { contains: keyword, mode: "insensitive" } },
+                                    { address: { contains: keyword, mode: "insensitive" } },
+                                    { Chain: { name: { contains: keyword, mode: "insensitive" } } },
+                                ],
+                            })),
+                        },
+                ],
             },
         };
     }

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

@@ -114,6 +114,13 @@ export declare abstract class TokenService {
     } & {
         price?: number | null | undefined;
     }>;
+    /**
+     * Checks if two tokens are the same based on chainId/address combo
+     * @param a token
+     * @param b token
+     * @returns true if both tokens are the same
+     */
+    static isSame(a: Pick<Token["model"], "chainId" | "address">, b: Pick<Token["model"], "chainId" | "address">): Promise<boolean>;
     /**
      * Get the list of tokens satisfying the query
      * @param query
@@ -134,6 +141,26 @@ export declare abstract class TokenService {
     } & {
         price?: number | null | undefined;
     })[]>;
+    /**
+     * Get the list of tokens satisfying the query or fetch if chainId and address are provided
+     * @param query
+     * @returns A list of tokens
+     */
+    static findManyOrFetch(query: GetTokenQueryModel): Promise<({
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+    } & {
+        price?: number | null | undefined;
+    })[]>;
     static getPrice(query: GetTokenQueryModel): Promise<number>;
     static findManyObjectPerAddress(query: GetTokenQueryModel): Promise<Record<string, {
         symbol: string;
@@ -256,10 +283,4 @@ export declare abstract class TokenService {
         isNative: boolean;
         price: number | null;
     }>;
-    /**
-     * @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

@@ -1,18 +1,16 @@
 import { HttpError } from "@/errors";
-import { getTokensListWithCache } from "@/libs/getTokensList";
 import { getOnlyUserBalance } from "@/libs/tokens/balances";
 import { BucketService } from "@/modules/v4/bucket/bucket.service";
+import { CacheService } from "@/modules/v4/cache";
+import { TTLPresets } from "@/modules/v4/cache/cache.model";
+import { CoingeckoService } from "@/modules/v4/coingecko/coingecko.service";
 import { IconService } from "@/modules/v4/icon/icon.service";
 import { PriceService } from "@/modules/v4/price/price.service";
 import { log } from "@/utils/logger";
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
-import { apiDbClient } from "@db";
 import { Prisma } from "@db/api";
 import { ChainInteractionService, DistributionCreatorService, NETWORK_LABELS, NULL_ADDRESS, bigIntToNumber, } from "@sdk";
-import { getAddress, parseUnits } from "viem";
-import { CacheService } from "../cache";
-import { TTLPresets } from "../cache/cache.model";
-import { CoingeckoService } from "../coingecko/coingecko.service";
+import { getAddress, isAddress, parseUnits } from "viem";
 import { TokenRepository } from "./token.repository";
 export class TokenService {
     static hashId(token) {
@@ -165,6 +163,15 @@ export class TokenService {
         const id = typeof token === "string" ? token : TokenService.hashId(token);
         return await TokenRepository.findUniqueOrThrow(id);
     }
+    /**
+     * Checks if two tokens are the same based on chainId/address combo
+     * @param a token
+     * @param b token
+     * @returns true if both tokens are the same
+     */
+    static async isSame(a, b) {
+        return a.chainId === b.chainId && a.address?.toLowerCase() === b.address?.toLowerCase();
+    }
     /**
      * Get the list of tokens satisfying the query
      * @param query
@@ -173,6 +180,22 @@ export class TokenService {
     static async findMany(query) {
         return (await TokenRepository.findMany(query)).map(TokenService.format);
     }
+    /**
+     * Get the list of tokens satisfying the query or fetch if chainId and address are provided
+     * @param query
+     * @returns A list of tokens
+     */
+    static async findManyOrFetch(query) {
+        const foundTokens = (await TokenRepository.findMany(query)).map(TokenService.format);
+        const isTokenAddress = query.chainId && query.search && isAddress(query.search);
+        if (isTokenAddress &&
+            !foundTokens.some(t => TokenService.isSame(t, { chainId: query.chainId, address: query.search }))) {
+            const token = await TokenService.fetchOnChain({ chainId: query.chainId, address: query.search });
+            //Assigning a temporary id since token is not in the database
+            token && foundTokens.push({ ...token, id: `tmp-${token.chainId}-${token.address}` });
+        }
+        return foundTokens;
+    }
     static async getPrice(query) {
         const tokensFound = (await TokenRepository.findMany(query)).map(TokenService.format);
         if (tokensFound.length === 0) {
@@ -343,77 +366,4 @@ export class TokenService {
         }
         return await TokenRepository.upsert({ ...filledData, ...token, id });
     }
-    /**
-     * @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,
-                            isPoint: 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) { }
-            }
-        }
-    }
 }