@merkl/api 0.9.15

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

@@ -0,0 +1,114 @@
+import { type ChainId } from "@sdk";
+import type { GetTokenQueryModel, Token, TokenModel, UpdateTokenModel } from "./token.model";
+export declare abstract class TokenRepository {
+    #private;
+    /**
+     * Fetch token metadata from onchain
+     * @param chainId
+     * @param address
+     */
+    static getTokenInfo(token: TokenModel): Promise<any>;
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static findUnique(id: string): Promise<Token["model"] | undefined>;
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static findUniqueOrThrow(id: string): Promise<Token["model"]>;
+    /**
+     * Read token from database by its symbol
+     * @param symbol
+     */
+    static findMany(query: GetTokenQueryModel): Promise<{
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        displaySymbol: string;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+        price: number | null;
+    }[]>;
+    static findList(chainId: number, addresses: string[]): Promise<{
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        displaySymbol: string;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+        price: number | null;
+    }[]>;
+    static countMany(query: GetTokenQueryModel): Promise<number>;
+    /**
+     * upsert a token on database
+     * @param token
+     */
+    static upsert(token: Token["model"]): Promise<{
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        displaySymbol: string;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+        price: number | null;
+    }>;
+    /**
+     * Updates price of tokens that share the same symbol
+     * @param symbol
+     * @param price value
+     * @param excludeAddresses to not update even if symbol match
+     */
+    static updateSymbolPrices(symbol: string, price: number, excludeAddresses: string[]): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    /**
+     * Updates price of tokens that share the same address
+     * @param address
+     * @param price value
+     * @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
+     * @param token
+     */
+    static create(token: Token["model"]): Promise<Token["model"] | undefined>;
+    static update(id: string, data: UpdateTokenModel): Promise<{
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        displaySymbol: string;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+        price: number | null;
+    }>;
+}

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

@@ -0,0 +1,169 @@
+import { apiDbClient } from "@db";
+import { NETWORK_LABELS, TokenInteractionService } from "@sdk";
+import axios from "axios";
+export class TokenRepository {
+    static #transformQueryToPrismaFilters(query) {
+        const ids = query.id ? query.id.map(id => ({ id })) : [];
+        return {
+            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,
+            },
+        };
+    }
+    /**
+     * Fetch token metadata from onchain
+     * @param chainId
+     * @param address
+     */
+    static async getTokenInfo(token) {
+        return TokenInteractionService(token.chainId).info(token.address);
+    }
+    /**
+     * 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
+     */
+    static async findMany(query) {
+        const args = TokenRepository.#transformQueryToPrismaFilters(query);
+        const tokens = await apiDbClient.token.findMany({
+            ...args,
+        });
+        return tokens;
+    }
+    static async findList(chainId, addresses) {
+        const tokens = await apiDbClient.token.findMany({
+            where: {
+                chainId,
+                address: {
+                    in: addresses,
+                },
+            },
+        });
+        return tokens;
+    }
+    static async countMany(query) {
+        const args = TokenRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.token.count(args);
+    }
+    /**
+     * upsert a token on database
+     * @param token
+     */
+    static async upsert(token) {
+        return await apiDbClient.token.upsert({
+            create: token,
+            update: token,
+            where: { id: token.id },
+        });
+    }
+    /**
+     * Updates price of tokens that share the same symbol
+     * @param symbol
+     * @param price value
+     * @param excludeAddresses to not update even if symbol match
+     */
+    static async updateSymbolPrices(symbol, price, excludeAddresses) {
+        return await apiDbClient.token.updateMany({
+            data: { price },
+            where: {
+                symbol,
+                address: { notIn: excludeAddresses },
+            },
+        });
+    }
+    /**
+     * Updates price of tokens that share the same address
+     * @param address
+     * @param price value
+     * @param chainId
+     */
+    static async updateAddressPrices(address, price, chainId) {
+        return await apiDbClient.token.updateMany({
+            data: { price },
+            where: {
+                chainId: chainId && { equals: chainId },
+                address: { equals: address, mode: "insensitive" },
+            },
+        });
+    }
+    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 },
+        });
+        return tokens.reduce((acc, token) => {
+            acc[token.id] = token.chainId;
+            return acc;
+        }, {});
+    }
+    /**
+     * create a token on database
+     * @param token
+     */
+    static async create(token) {
+        return await apiDbClient.token.create({
+            data: {
+                ...token,
+                chainId: undefined,
+                Chain: {
+                    connectOrCreate: {
+                        where: { id: token.chainId },
+                        create: { id: token.chainId, name: NETWORK_LABELS[token.chainId], icon: "" },
+                    },
+                },
+            },
+        });
+    }
+    static async update(id, data) {
+        return await apiDbClient.token.update({ where: { id }, data });
+    }
+}

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

@@ -0,0 +1,266 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters, type ChainId } from "@sdk";
+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;
+    static format(token: Awaited<ReturnType<typeof TokenRepository.findMany>>[number]): Token["model"];
+    static fetchNativeBalance(chainId: number, userAddress: string): Promise<any>;
+    /**
+     * Fetches balances of provided tokens
+     */
+    static fetchBalances(chainId: number, userAddress: string, tokens: Token["model"][]): Promise<(Token["model"] & {
+        balance: bigint;
+    })[]>;
+    /**
+     * Fetches tokens and include balances
+     */
+    static fetchTokensAndBalances(chainId: number, userAddress: string, addresses: string[]): 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;
+    } & {
+        balance: bigint;
+    })[]>;
+    /**
+     * Fetches balances of verified tokens
+     * @info tokens that are popular and must be detected in the app are marked as 'verified'
+     * @param additionalTokens balances along with the verified ones
+     */
+    static fetchVerifiedAndNativeBalances(chainId: number, userAddress: string, additionalTokenAddresses?: string[]): 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;
+    } & {
+        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;
+            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;
+        }, "id">;
+    }>;
+    /**
+     * Updates price of tokens that share the same symbol
+     * @param symbol
+     * @param price value
+     * @param excludeAddresses to not update symbols that defined using addresses
+     */
+    static updateSymbolPrices(symbol: string, price: number, excludeAddresses: string[]): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    /**
+     * Updates price of tokens that share the same address
+     * @param address
+     * @param price value
+     * @param chainId
+     */
+    static updateAddressPrices(address: string, price: number, chainId?: number): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    /**
+     * Updates price of tokens that share the same symbol
+     * @param symbol
+     * @param price value
+     * @param excludeAddresses to not update symbols that defined using addresses
+     */
+    static updatePrices(pricer: Pricer): Promise<void>;
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static findUniqueOrThrow(token: TokenUnique | string): 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;
+    }>;
+    /**
+     * Get the list of tokens satisfying the query
+     * @param query
+     * @returns A list of tokens
+     */
+    static findMany(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;
+        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 getRewardTokenPrice(campaign: CampaignParameters<Campaign>): Promise<number>;
+    /**
+     * Get value of tokens
+     * @param tokenAmounts address/chain + amount of token
+     * @returns the cumulated dollar value of all tokens
+     */
+    static getValue(tokenAmounts: {
+        amount?: bigint;
+        address: string;
+        chainId: number;
+    }[]): Promise<number>;
+    static getValueByTokenId(tokenAmountMap: Map<string, bigint>): Promise<number>;
+    /**
+     * Counts the number of tokens that complies to query
+     * @description used for pagination purposes
+     * @param query
+     * @returns the number of tokens
+     */
+    static countMany(query: GetTokenQueryModel): Promise<number>;
+    static findChains(): Promise<Record<string, ChainId>>;
+    /**
+     * Read token from DB or fetch onchain
+     * @param chainId
+     * @param address
+     */
+    static findManyOrCreate(tokens: TokenModel[]): 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 getValidRewardTokens(chainId: number): Promise<{
+        minimumAmountPerHour: any;
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        displaySymbol: string;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+        price: number | null;
+    }[]>;
+    static update(id: string, data: UpdateTokenModel): Promise<{
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        displaySymbol: string;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+        price: number | null;
+    }>;
+    static notionWebhook(body: NotionWebhookModel): Promise<{
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        displaySymbol: string;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        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;
+        address: string;
+        chainId: number;
+        decimals: number;
+        displaySymbol: string;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+        price: number | null;
+    } | 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>;
+}