@merkl/api 0.21.47 → 1.0.0

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

@@ -1,146 +0,0 @@
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { apiDbClient } from "@db";
-import moment from "moment";
-export class StatusRepository {
-    static #formatQuery(query) {
-        return {
-            where: {
-                status: Array.isArray(query.status) ? { in: query.status } : query.status,
-                Campaign: query.computeChainId ? { computeChainId: query.computeChainId } : undefined,
-            },
-            include: { Campaign: Boolean(query.status) },
-        };
-    }
-    static async findMany(query) {
-        return await apiDbClient.campaignStatus.findMany(StatusRepository.#formatQuery(query));
-    }
-    static async findManyByCampaignId(campaignId) {
-        return await apiDbClient.campaignStatus.findMany({
-            where: {
-                Campaign: {
-                    campaignId: campaignId,
-                },
-            },
-        });
-    }
-    static async findUniqueOrThrow(campaignId) {
-        return await apiDbClient.campaignStatus.findUniqueOrThrow({
-            where: {
-                campaignId,
-            },
-        });
-    }
-    static async findUnique(campaignUnique) {
-        return await apiDbClient.campaignStatus.findUnique({
-            where: {
-                campaignId: CampaignService.hashId(campaignUnique),
-            },
-        });
-    }
-    static async create(campaign, startTimestamp) {
-        return await apiDbClient.campaignStatus.create({
-            data: {
-                campaignId: CampaignService.hashId(campaign),
-                computedUntil: startTimestamp,
-                processingStarted: startTimestamp,
-            },
-        });
-    }
-    static async updateSuccess(campaignUnique, computedUntil) {
-        return await apiDbClient.campaignStatus.update({
-            where: {
-                campaignId: CampaignService.hashId(campaignUnique),
-            },
-            data: {
-                computedUntil,
-                status: "SUCCESS",
-                error: "",
-                details: "{}",
-            },
-        });
-    }
-    static async updateWithError(campaignUnique, status, error, details) {
-        return await apiDbClient.campaignStatus.update({
-            where: {
-                campaignId: CampaignService.hashId(campaignUnique),
-            },
-            data: {
-                status,
-                error: error?.length > 0 ? error : undefined,
-                details,
-            },
-        });
-    }
-    static async updateProcessing(campaignUnique) {
-        const campaignId = CampaignService.hashId(campaignUnique);
-        const now = moment().unix();
-        await apiDbClient.campaignStatus.update({
-            where: {
-                campaignId,
-                processingStarted: {
-                    lte: now - 60, // The job wasn't already updated in the last minute
-                },
-            },
-            data: {
-                status: "PROCESSING",
-                processingStarted: moment().unix(),
-                error: "",
-                details: "{}",
-            },
-        });
-    }
-    static async updateComputedUntil(campaignUnique, computedUntil) {
-        return await apiDbClient.campaignStatus.update({
-            where: {
-                campaignId: CampaignService.hashId(campaignUnique),
-            },
-            data: {
-                computedUntil,
-            },
-        });
-    }
-    static async updateErrorMessage(campaignUnique, error) {
-        return await apiDbClient.campaignStatus.update({
-            where: {
-                campaignId: CampaignService.hashId(campaignUnique),
-            },
-            data: {
-                error,
-            },
-        });
-    }
-    static async findManyDelay(query) {
-        return await apiDbClient.campaign.findMany({
-            where: {
-                distributionChainId: !!query.chainId ? query.chainId : undefined,
-                endTimestamp: {
-                    gte: !!query.endTimestampLowerBound ? query.endTimestampLowerBound : moment().subtract(2, "week").unix(),
-                },
-            },
-            select: {
-                campaignId: true,
-                computeChainId: true,
-                startTimestamp: true,
-                endTimestamp: true,
-                distributionChainId: true,
-                RewardToken: {
-                    select: {
-                        address: true,
-                        symbol: true,
-                        isTest: true,
-                    },
-                },
-                Opportunity: {
-                    select: {
-                        name: true,
-                        identifier: true,
-                        type: true,
-                    },
-                },
-                CampaignStatus: {
-                    take: 1,
-                },
-            },
-        });
-    }
-}

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

@@ -1,150 +0,0 @@
-import { NotFoundError } from "@/errors";
-import { VoidString } from "@/errors/VoidString.error";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { MerklRootService } from "@/modules/v4/merklRoot/merklRoot.service";
-import { log } from "@/utils/logger";
-import { RunStatus } from "@db/api";
-import { HOUR, MAX_COMPUTE_JOB_TIME, NETWORK_LABELS, getMultisigURL, registry } from "@sdk";
-import moment from "moment";
-import { StatusRepository } from "./status.repository";
-export class StatusService {
-    static format(status) {
-        return {
-            ...status,
-            computedUntil: Number(status.computedUntil),
-            processingStarted: Number(status.processingStarted),
-        };
-    }
-    static async findMany(query) {
-        return await StatusRepository.findMany(query);
-    }
-    static async findManyByCampaignId(campaignId) {
-        return await StatusRepository.findManyByCampaignId(campaignId);
-    }
-    static async findUniqueOrThrow(campaignUnique) {
-        const campaignId = typeof campaignUnique === "string" ? campaignUnique : CampaignService.hashId(campaignUnique);
-        return await StatusRepository.findUniqueOrThrow(campaignId);
-    }
-    static async findUnique(campaignUnique) {
-        return await StatusRepository.findUnique(campaignUnique);
-    }
-    static async update(campaignUnique, status) {
-        // Check if the status exists already, otherwise create it
-        const campaignStatus = await StatusRepository.findUnique(campaignUnique);
-        if (!campaignStatus) {
-            let campaign = await CampaignService.findUnique(campaignUnique);
-            if (!campaign) {
-                await CampaignService.fill([campaignUnique]);
-                campaign = await CampaignService.findUniqueOrThrow(campaignUnique);
-            }
-            await StatusRepository.create(campaignUnique, campaign.startTimestamp);
-        }
-        // Update the run status
-        switch (status.value) {
-            case RunStatus.SUCCESS:
-                await StatusRepository.updateSuccess(campaignUnique, status.computedUntil);
-                return;
-            case RunStatus.PROCESSING:
-                await StatusRepository.updateProcessing(campaignUnique);
-                return;
-            case RunStatus.SKIPPED:
-                await StatusRepository.updateWithError(campaignUnique, status.value, status.error, status.details);
-                return;
-            case RunStatus.FAILED:
-                await StatusRepository.updateWithError(campaignUnique, status.value, status.error, status.details);
-                return;
-        }
-    }
-    static async updateComputedUntil(campaignUnique, computedUntil) {
-        // Check if the status exists already, otherwise create it
-        const campaignStatus = await StatusRepository.findUnique(campaignUnique);
-        if (!campaignStatus) {
-            let campaign = await CampaignService.findUnique(campaignUnique);
-            if (!campaign) {
-                await CampaignService.fill([campaignUnique]);
-                campaign = await CampaignService.findUniqueOrThrow(campaignUnique);
-            }
-            await StatusRepository.create(campaignUnique, campaign.startTimestamp);
-        }
-        await StatusRepository.updateComputedUntil(campaignUnique, computedUntil);
-    }
-    static async updateErrorMessage(campaignUnique, error) {
-        // Check if the status exists already, otherwise thros
-        const campaignStatus = await StatusRepository.findUnique(campaignUnique);
-        if (!(error?.length > 0)) {
-            throw new VoidString("Error message is empty");
-        }
-        if (!campaignStatus) {
-            throw new NotFoundError("CampaignStatus not found");
-        }
-        await StatusRepository.updateErrorMessage(campaignUnique, error);
-    }
-    static async isSafeForOverlaps(campaignUnique) {
-        const status = await StatusRepository.findUnique(campaignUnique);
-        if (!status) {
-            return true;
-        }
-        if (status.status === RunStatus.PROCESSING) {
-            return status.processingStarted < moment().unix() - MAX_COMPUTE_JOB_TIME;
-        }
-        return true;
-    }
-    static async findUpdatesAndDelays() {
-        const merklRoots = await MerklRootService.fetchAll();
-        const delayedCampaignPromises = Promise.allSettled(Object.keys(merklRoots).map(chainId => StatusService.findManyDelay({ chainId: Number.parseInt(chainId), delayLowerBound: 9 * HOUR })));
-        const liveCampaignPromises = await Promise.allSettled(Object.keys(merklRoots).map(chainId => CampaignService.countLives({ distributionChainId: Number.parseInt(chainId) })));
-        const delayedCampaignArray = await delayedCampaignPromises;
-        const liveCampaignArray = await liveCampaignPromises;
-        const res = {};
-        for (const [index, chainIdString] of Object.keys(merklRoots).entries()) {
-            const chainId = Number.parseInt(chainIdString);
-            const delayedCampaignResult = delayedCampaignArray[index];
-            const liveCampaignResult = liveCampaignArray[index];
-            const delayedCampaigns = delayedCampaignResult.status === "rejected" ? [] : delayedCampaignResult.value;
-            if (delayedCampaignResult.status === "rejected") {
-                log.warn(`delayed campaigns fetching failed on ${NETWORK_LABELS[chainId]}: ${delayedCampaignResult.reason}`);
-            }
-            const liveCampaigns = liveCampaignResult.status === "rejected" ? 0 : liveCampaignResult.value;
-            if (liveCampaignResult.status === "rejected") {
-                log.warn(`live campaigns fetching failed on ${NETWORK_LABELS[chainId]}: ${liveCampaignResult.reason}`);
-            }
-            if (!registry(chainId)?.Merkl?.DistributionCreator || !registry(chainId)?.Merkl?.Distributor) {
-                log.warn(`Missing registry for ${NETWORK_LABELS[chainId]}`);
-                continue;
-            }
-            let adminUrl = undefined;
-            try {
-                adminUrl = getMultisigURL(chainId, registry(chainId)?.AngleLabs ?? "");
-            }
-            catch { }
-            res[chainId] = {
-                ...merklRoots[chainId],
-                admin: registry(chainId)?.AngleLabs ?? "0xb08AB4332AD871F89da24df4751968A61e58013c",
-                adminUrl,
-                distributor: registry(chainId)?.Merkl?.Distributor,
-                distributionCreator: registry(chainId)?.Merkl?.DistributionCreator,
-                liveCampaigns,
-                delayed: delayedCampaigns,
-            };
-        }
-        return res;
-    }
-    static async findManyDelay(query) {
-        const now = moment().unix();
-        return (await StatusRepository.findManyDelay(query))
-            .map(x => {
-            const endTimestamp = Number(x.endTimestamp);
-            const computedUntil = !!Number(x.CampaignStatus?.[0]?.computedUntil)
-                ? Number(x.CampaignStatus?.[0]?.computedUntil)
-                : Number(x.startTimestamp);
-            const delay = Math.min(now, endTimestamp) - Math.min(now, endTimestamp, computedUntil);
-            return {
-                ...x,
-                delay,
-                computedUntil,
-            };
-        })
-            .sort((a, b) => b.delay - a.delay)
-            .filter(x => x.delay > (query.delayLowerBound ?? 0));
-    }
-}

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

@@ -1,118 +0,0 @@
-import { NotFoundError } from "@/errors/NotFound.error";
-import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { getUserAllowance } from "@/libs/tokens/allowances";
-import { throwOnInvalidAddress, throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
-import Elysia, { t } from "elysia";
-import { CreateTokenDto, FindUniqueTokenAllowanceDto, FindUniqueTokenDto, GetTokenBalanceDto, GetTokenQueryDto, NotionWebhookAddTokenDto, TokenIdDto, UpdateTokenDto, } from "./token.model";
-import { TokenService } from "./token.service";
-// ─── Tokens Controller ───────────────────────────────────────────────────────
-export const TokenController = new Elysia({ prefix: "/tokens", detail: { tags: ["Tokens"] } })
-    // ─── Get A Token By Id ───────────────────────────────────────────────
-    .get("/:id", async ({ params }) => {
-    try {
-        const [chainId, address] = params.id.split("-");
-        return await TokenService.findUniqueOrThrow({ chainId: +chainId, address });
-    }
-    catch (err) {
-        if (err.code && err.code === "P2025")
-            throw new NotFoundError();
-    }
-}, {
-    params: FindUniqueTokenDto,
-    detail: {
-        hide: true,
-    },
-})
-    .get("/:id/allowance/:owner/:spender", async ({ params: { id, owner, spender } }) => {
-    try {
-        const [chainId, address] = id.split("-");
-        const token = await TokenService.findUniqueOrThrow({ chainId: +chainId, address });
-        const allowance = await getUserAllowance(token.chainId, token.address, owner, spender);
-        return { ...token, allowance };
-    }
-    catch (err) {
-        if (err.code && err.code === "P2025")
-            throw new NotFoundError();
-    }
-}, {
-    params: FindUniqueTokenAllowanceDto,
-    detail: {
-        hide: true,
-    },
-})
-    // ─── Get All Valid Reward Tokens across all chains ───────────────────
-    .get("/reward", async ({ query }) => TokenService.getAllValidRewardTokens(query), {
-    query: t.Object({
-        chainId: t.Optional(t.RegExp(/^\d+(,\d+)*$/)),
-    }),
-    detail: {
-        description: "Get all tokens that are accept as reward tokens",
-    },
-})
-    // ─── Get Valid Reward Tokens on a given chain ────────────────────────
-    .get("/reward/:chainId", async ({ params }) => TokenService.getValidRewardTokens(params.chainId), {
-    params: t.Object({
-        chainId: t.Numeric(),
-    }),
-    beforeHandle: ({ params }) => throwOnUnsupportedChainId(params.chainId),
-    detail: {
-        description: "Get the list of tokens that are accept as reward tokens on a given chain",
-    },
-})
-    // ─── Get Tokens With Balances ────────────────────────────────────────
-    .get("/balances", async ({ query: { chainId, userAddress, tokenAddress, additionalTokenAddresses } }) => {
-    if (tokenAddress)
-        return await TokenService.fetchTokensAndBalances(chainId, userAddress, [tokenAddress].concat(additionalTokenAddresses ?? []));
-    return await TokenService.fetchVerifiedAndNativeBalances(chainId, userAddress, additionalTokenAddresses);
-}, {
-    beforeHandle: ({ query }) => {
-        throwOnUnsupportedChainId(query.chainId);
-        query.userAddress = throwOnInvalidRequiredAddress(query.userAddress);
-        query.tokenAddress = throwOnInvalidAddress(query.tokenAddress);
-    },
-    query: GetTokenBalanceDto,
-    detail: {
-        hide: true,
-    },
-})
-    // ─── Get Many Tokens ─────────────────────────────────────────────────
-    .get("/", async ({ query }) => await TokenService.findManyOrFetch(query), {
-    query: GetTokenQueryDto,
-    detail: {
-        hide: true,
-    },
-})
-    // ─── Count Tokens ────────────────────────────────────────────────────
-    .get("/count", async ({ query }) => await TokenService.countMany(query), {
-    query: GetTokenQueryDto,
-    detail: {
-        hide: true,
-    },
-})
-    // ─── Create a new Token entity ────────────────────────────────────────────
-    .post("/", async ({ body }) => await TokenService.fillAndCreate(body), {
-    body: CreateTokenDto,
-    headers: AuthorizationHeadersDto,
-    beforeHandle: async ({ headers, body }) => {
-        BackOfficeGuard({ headers });
-        body.address = throwOnInvalidRequiredAddress(body.address);
-        throwOnUnsupportedChainId(body.chainId);
-    },
-    detail: { hide: true },
-})
-    // ─── Update token fields Status ────────────────────────────────────────────
-    .patch("/:id", async ({ params, body }) => await TokenService.update(params.id, body), {
-    params: TokenIdDto,
-    body: UpdateTokenDto,
-    headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
-    detail: { hide: true },
-})
-    .group("/webhooks", app => {
-    return app.post("/notion", async ({ body }) => TokenService.notionWebhook(body), {
-        body: NotionWebhookAddTokenDto,
-        headers: AuthorizationHeadersDto,
-        beforeHandle: BackOfficeGuard,
-        detail: { hide: true },
-    });
-});

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

@@ -1,87 +0,0 @@
-import { t } from "elysia";
-// ─── Dtos ────────────────────────────────────────────────────────────────────
-export const TokenResourceDto = t.Object({
-    id: t.String(),
-    name: t.Union([t.String(), t.Null()]),
-    chainId: t.Number(),
-    address: t.String(),
-    decimals: t.Number(),
-    icon: t.String(),
-    verified: t.Boolean(),
-    isTest: t.Boolean(),
-    isPoint: t.Boolean(),
-    isPreTGE: t.Boolean(),
-    price: t.Optional(t.Union([t.Union([t.Number(), t.Null()])])),
-    symbol: t.String(),
-});
-export const FindUniqueTokenDto = t.Object({
-    id: t.String(),
-});
-export const FindUniqueTokenAllowanceDto = t.Object({
-    id: t.String(),
-    owner: t.String(),
-    spender: t.String(),
-});
-export const GetTokenQueryDto = t.Object({
-    id: t.Optional(t.Array(t.String())),
-    symbol: t.Optional(t.String()),
-    displaySymbol: t.Optional(t.String()), // To filter by displaySymbol or if null symbol
-    chainId: t.Optional(t.Numeric()),
-    isNative: t.Optional(t.Boolean()),
-    address: t.Optional(t.String()),
-    name: t.Optional(t.String()),
-    search: t.Optional(t.String()),
-    page: t.Optional(t.Number()),
-    items: t.Optional(t.Number()),
-    verified: t.Optional(t.Boolean()),
-    test: t.Optional(t.Boolean()),
-    missingIcons: t.Optional(t.Boolean()),
-    missingPrice: t.Optional(t.Boolean()),
-});
-export const TokenDto = t.Object({
-    address: t.String(),
-    chainId: t.Numeric(),
-});
-export const GetTokenBalanceDto = t.Object({
-    chainId: t.Numeric(),
-    userAddress: t.String(),
-    verified: t.Optional(t.Boolean()),
-    tokenAddress: t.Optional(t.String({ description: "If provided, the default verified token balances won't be included" })),
-    additionalTokenAddresses: t.Optional(t.Array(t.String())),
-});
-export const TokenIdDto = t.Object({ id: t.String() });
-export const UpdateTokenDto = t.Object({
-    isTest: t.Optional(t.Boolean()),
-    isPoint: t.Optional(t.Boolean()),
-    isPreTGE: t.Optional(t.Boolean()),
-    verified: t.Optional(t.Boolean()),
-    icon: t.Optional(t.String({ format: "uri" })),
-    // iconFile: t.Optional(t.File()),
-    displaySymbol: t.Optional(t.String()),
-    name: t.Optional(t.String()),
-});
-export const CreateTokenDto = t.Object({
-    chainId: t.Numeric(),
-    address: t.String(),
-    icon: t.String(),
-    verified: t.Boolean(),
-    isTest: t.Optional(t.Boolean()),
-});
-export const NotionWebhookAddTokenDto = t.Object({
-    data: t.Object({
-        properties: t.Object({
-            "Icon (Required)": t.Object({
-                files: t.Array(t.Union([
-                    t.Object({ file: t.Object({ url: t.String() }) }),
-                    t.Object({ external: t.Object({ url: t.String() }) }),
-                ])),
-            }),
-            "Address (in checksum format) (Required)": t.Object({
-                rich_text: t.Array(t.Object({ plain_text: t.String() })),
-            }),
-            "Chain ID (Required)": t.Object({ number: t.Numeric() }),
-            "Symbol (Optional)": t.Object({ rich_text: t.Array(t.Object({ plain_text: t.String() })) }),
-            "CoinGecko API ID (Recommended)": t.Object({ rich_text: t.Array(t.Object({ plain_text: t.String() })) }),
-        }),
-    }),
-}, { additionalProperties: true });

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

@@ -1,192 +0,0 @@
-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 })) : [];
-        const { page: _page, items: _items } = query;
-        const page = _page ? _page : 0;
-        const items = _items === 0 ? 100_000 : _items !== undefined ? _items : 100;
-        return {
-            take: items === 0 ? undefined : items,
-            skip: page * items,
-            where: {
-                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" } } },
-                                ],
-                            })),
-                        },
-                ],
-            },
-        };
-    }
-    /**
-     * 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 });
-    }
-}