@merkl/api 0.21.47 → 1.0.3

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

@@ -1,410 +0,0 @@
-import { HttpError } from "@/errors";
-import { getOnlyUserBalance } from "@/libs/tokens/balances";
-import { BucketService } from "@/modules/v4/bucket/bucket.service";
-import { TTLPresets } from "@/modules/v4/cache/cache.model";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-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 { Prisma } from "@db/api";
-import { ChainInteractionService, DistributionCreatorService, NETWORK_LABELS, NULL_ADDRESS, bigIntToNumber, withTimeout, } from "@sdk";
-import { getAddress, isAddress, parseUnits } from "viem";
-import { ChainService } from "../chain/chain.service";
-import { TokenRepository } from "./token.repository";
-export class TokenService {
-    static hashId(token) {
-        return Bun.hash(`${token.chainId}${token.address}`).toString();
-    }
-    static format(token) {
-        const { displaySymbol, symbol, ...rest } = token;
-        return {
-            ...rest,
-            symbol: !displaySymbol || displaySymbol === "" ? symbol : displaySymbol,
-        };
-    }
-    static async fetchNativeBalance(chainId, userAddress) {
-        return await ChainInteractionService(chainId).provider().getBalance(userAddress);
-    }
-    /**
-     * Fetches balances of provided tokens
-     */
-    static async fetchBalances(chainId, userAddress, tokens) {
-        const nativeTokenBalance = await TokenService.fetchNativeBalance(chainId, userAddress);
-        const balances = await getOnlyUserBalance(chainId, userAddress, tokens.filter(({ isNative }) => !isNative).map(t => t.address));
-        const tokensWithBalances = tokens.map(t => {
-            const balance = (() => {
-                if (t.isNative)
-                    return { balance: nativeTokenBalance.toString() };
-                return (balances[t.address] ??
-                    balances[Object.keys(balances).find(a => a?.toLowerCase() === t.address?.toLowerCase()) ?? ""]);
-            })();
-            return Object.assign(t, { balance: BigInt(balance?.balance ?? 0) });
-        });
-        return tokensWithBalances.sort((b, a) => {
-            const aN = parseUnits(a.balance.toString(), a.decimals);
-            const bN = parseUnits(b.balance.toString(), b.decimals);
-            return aN < bN ? -1 : aN > bN ? 1 : 0;
-        });
-    }
-    /**
-     * Fetches tokens and include balances
-     */
-    static async fetchTokensAndBalances(chainId, userAddress, addresses) {
-        const tokens = await TokenService.findManyOrCreate(addresses?.map(address => ({ chainId, address })));
-        return TokenService.fetchBalances(chainId, userAddress, tokens);
-    }
-    /**
-     * 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 async fetchVerifiedAndNativeBalances(chainId, userAddress, additionalTokenAddresses) {
-        const verifiedTokens = await CacheService.wrap(TTLPresets.MIN_5, TokenService.findMany, {
-            chainId,
-            verified: true,
-        });
-        const nativeTokens = (await CacheService.wrap(TTLPresets.MIN_5, TokenService.findMany, {
-            chainId,
-            isNative: true,
-        })).filter(t => !!t);
-        const additionalTokens = !!additionalTokenAddresses?.length
-            ? await TokenService.findManyOrCreate(additionalTokenAddresses?.map(address => ({ chainId, address })))
-            : [];
-        const allTokens = verifiedTokens.concat(additionalTokens).concat(nativeTokens);
-        return TokenService.fetchBalances(chainId, userAddress, allTokens);
-    }
-    static async fetchOnChain(token) {
-        const onchainData = token.address === NULL_ADDRESS
-            ? {
-                name: `${NETWORK_LABELS[token.chainId]} Native Token`,
-                symbol: `${NETWORK_LABELS[token.chainId]} Native Token`,
-                decimals: 18,
-            }
-            : await TokenRepository.getTokenInfo(token);
-        try {
-            // biome-ignore lint/suspicious/noControlCharactersInRegex: <explanation>
-            onchainData.name = Buffer.from(onchainData.name.replace(/\u0000/g, ""), "utf-8").toString("utf-8");
-            // biome-ignore lint/suspicious/noControlCharactersInRegex: <explanation>
-            onchainData.symbol = Buffer.from(onchainData.symbol.replace(/\u0000/g, ""), "utf-8").toString("utf-8");
-        }
-        catch (e) {
-            console.error(e);
-        }
-        return {
-            chainId: token.chainId,
-            address: token.address,
-            icon: "",
-            ...Object.assign({
-                name: "unknown",
-                decimals: 18,
-                symbol: "UNKNOWN",
-                verified: false,
-                isTest: false,
-                isPoint: false,
-                isPreTGE: false,
-                isNative: false,
-            }, onchainData),
-        };
-    }
-    static async fetchManyOnChain(chainId, addresses) {
-        const tokens = {};
-        // Batch onchain calls together when multiples
-        for (const address of addresses) {
-            tokens[address] = await TokenService.fetchOnChain({ chainId, address });
-        }
-        return tokens;
-    }
-    /**
-     * 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 async updateSymbolPrices(symbol, price, excludeAddresses) {
-        return await TokenRepository.updateSymbolPrices(symbol, price, 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 TokenRepository.updateAddressPrices(address, price, chainId);
-    }
-    /**
-     * 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 async updatePrices(pricer) {
-        const pricedAddresses = Object.keys(pricer.prices).filter(address => address.startsWith("0x"));
-        const symbols = Object.keys(pricer.prices).filter(address => !address.startsWith("0x"));
-        for (const symbol of symbols) {
-            const price = await pricer.get({ symbol });
-            if (!price)
-                continue;
-            await TokenService.updateSymbolPrices(symbol, price, pricedAddresses);
-        }
-        for (const address of pricedAddresses) {
-            const price = await pricer.get({ address });
-            if (!price)
-                continue;
-            await TokenService.updateAddressPrices(address, price);
-        }
-    }
-    /**
-     * Read token from database
-     * @param chainId
-     * @param address
-     */
-    static async findUniqueOrThrow(token) {
-        const id = typeof token === "string" ? token : TokenService.hashId(token);
-        return await TokenRepository.findUniqueOrThrow(id);
-    }
-    /**
-     * Read token from database, tries to fill it if unexistant
-     * @param chainId
-     * @param address
-     */
-    static async findUniqueFillOrThrow(token) {
-        const id = TokenService.hashId(token);
-        let result = await TokenRepository.findUnique(id);
-        if (!result) {
-            await TokenService.fillAndCreate({
-                chainId: token.chainId,
-                address: token.address,
-                verified: false,
-                icon: "",
-            });
-            result = await TokenRepository.findUniqueOrThrow(id);
-        }
-        return result;
-    }
-    /**
-     * 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
-     * @returns A list of tokens
-     */
-    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 isTokenAddress = query.chainId && query.search && isAddress(query.search);
-        const foundTokens = (await TokenRepository.findMany(isTokenAddress ? { ...query, address: query.search } : query)).map(TokenService.format);
-        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) {
-            log.warn(`TokenService.getPrice: No token found for ${query.address} on ${query.chainId ? NETWORK_LABELS[query.chainId] : "unknwon"}. Returning 0 as price.`);
-            return 0;
-        }
-        // In the case of points, we want to be able to compute X points distributed per $ of TVL, hence returning 1.
-        const priceToken = tokensFound[0].isPoint ? 1 : (tokensFound[0].price ?? 0);
-        return priceToken;
-    }
-    static async findManyObjectPerAddress(query) {
-        return (await CacheService.wrap(TTLPresets.MIN_10, TokenService.findMany, query)).reduce((acc, token) => {
-            acc[token.address] = token;
-            return acc;
-        }, {});
-    }
-    static async getRewardTokenPrice(campaign) {
-        const query = {
-            chainId: campaign.chainId,
-            address: campaign.rewardToken,
-            symbol: campaign.campaignParameters.symbolRewardToken,
-        };
-        const priceRewardToken = await TokenService.getPrice(query);
-        return priceRewardToken;
-    }
-    /**
-     * Get value of tokens
-     * @param tokenAmounts address/chain + amount of token
-     * @returns the cumulated dollar value of all tokens
-     */
-    static async getValue(tokenAmounts) {
-        const tokens = await TokenService.findManyOrCreate(tokenAmounts.map(({ address, chainId }) => ({ address, chainId })));
-        return tokenAmounts.reduce((sum, { amount, address, chainId }) => {
-            const token = tokens.find(({ address: addr, chainId: chain }) => addr === address && chainId === chain);
-            if (!token)
-                return sum;
-            const value = (bigIntToNumber(amount ?? 0n, token.decimals) ?? 0) * (token.price ?? 0);
-            return sum + value;
-        }, 0);
-    }
-    static async getValueByTokenId(id, amount) {
-        const token = await TokenService.findUniqueOrThrow(id);
-        return (bigIntToNumber(amount, token.decimals) ?? 0) * (token.price ?? 0);
-    }
-    /**
-     * Counts the number of tokens that complies to query
-     * @description used for pagination purposes
-     * @param query
-     * @returns the number of tokens
-     */
-    static async countMany(query) {
-        return await TokenRepository.countMany(query);
-    }
-    static async findChains() {
-        return await TokenRepository.findChains();
-    }
-    /**
-     * Read token from DB or fetch onchain
-     * @param chainId
-     * @param address
-     */
-    static async findManyOrCreate(tokens) {
-        return await Promise.all(tokens.map(async (token) => {
-            const id = TokenService.hashId(token);
-            try {
-                return await TokenRepository.findUniqueOrThrow(id);
-            }
-            catch (err) {
-                try {
-                    if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2025") {
-                        return TokenService.format(await TokenService.fillAndCreate({
-                            ...token,
-                            verified: false,
-                            icon: "",
-                        }));
-                    }
-                }
-                catch (_err) { }
-                throw new HttpError(`Failed to fetch or create token ${token.address} on chain ${token.chainId}.`);
-            }
-        }));
-    }
-    static async getAllValidRewardTokens(query) {
-        const chainIds = !!query.chainId
-            ? query.chainId?.split(",").map(n => Number.parseInt(n))
-            : (await ChainService.findMany({
-                test: true,
-            })).map(chain => chain.id);
-        return await CacheService.wrap(TTLPresets.MIN_5, async (chainIds) => {
-            /** Fetch current Merkle Roots */
-            const promises = await Promise.allSettled(chainIds.map(chainId => withTimeout(TokenService.getValidRewardTokens(chainId), 5_000)));
-            /** Filter out unsuccessful chainIds */
-            chainIds = chainIds.filter((_, index) => promises[index].status === "fulfilled");
-            return promises
-                .filter(({ status }) => status === "fulfilled")
-                .reduce((acc, promise, index) => {
-                acc[chainIds[index]] = promise.value;
-                return acc;
-            }, {});
-        }, chainIds);
-    }
-    static async getValidRewardTokens(chainId) {
-        const validRewardTokens = await DistributionCreatorService(chainId).validRewardTokens();
-        return (await TokenRepository.findList(chainId, validRewardTokens.map(t => getAddress(t.token)))).map(x => {
-            return {
-                ...x,
-                minimumAmountPerHour: validRewardTokens
-                    .find(t => getAddress(t.token) === x.address)
-                    ?.minimumAmountPerEpoch.toString(),
-            };
-        });
-    }
-    static async update(id, data) {
-        return await TokenRepository.update(id, data);
-    }
-    static async notionWebhook(body) {
-        const env = process.env.ENV === "prod" ? "production" : process.env.ENV;
-        const properties = body.data.properties;
-        const file = properties["Icon (Required)"].files[0];
-        const iconURL = "external" in file ? file.external.url : file.file.url;
-        const icon = await fetch(iconURL);
-        const mimeType = icon.headers.get("content-type");
-        const extension = mimeType.split("/")[1].split("+")[0];
-        const address = throwOnInvalidRequiredAddress(properties["Address (in checksum format) (Required)"].rich_text[0].plain_text);
-        const chainId = properties["Chain ID (Required)"].number;
-        throwOnUnsupportedChainId(chainId);
-        const displaySymbol = properties["Symbol (Optional)"].rich_text[0]?.plain_text;
-        const coingeckoApiId = properties["CoinGecko API ID (Recommended)"].rich_text[0]?.plain_text;
-        const [token] = await TokenService.findManyOrCreate([
-            {
-                chainId,
-                address,
-            },
-        ]);
-        if (!token || !token.name)
-            throw new HttpError(`Failed to fetch on-chain data for token ${token?.symbol} (${address} on chainId ${chainId}).`);
-        try {
-            await IconService.pullPush(iconURL, new BucketService("merkl-static-assets", `angle-${env}-1`), {
-                name: `tokens/${token.symbol}`,
-            });
-            token.icon = `${process.env.GCS_ENDPOINT}/merkl-static-assets/tokens/${token.symbol}.${extension}`;
-        }
-        catch (err) {
-            log.error(`[${token.id} (${chainId} | ${address})] Failed to pull / push from Notion to GCP. Using Notion URI for now.`, err);
-            token.icon = iconURL;
-        }
-        if (coingeckoApiId) {
-            try {
-                await PriceService.createPriceSource({
-                    method: "COINGECKO",
-                    symbol: token.symbol,
-                    args: { ticker: coingeckoApiId },
-                });
-            }
-            catch (err) {
-                log.error("Failed to create price source.", err);
-            }
-        }
-        return await TokenService.update(token.id, {
-            icon: token.icon,
-            displaySymbol: displaySymbol && displaySymbol !== "" ? displaySymbol : token.symbol,
-            name: token.name,
-            verified: true,
-        });
-    }
-    /**
-     * Fetches symbol, address, decimals and creates token on database
-     * @param chainId
-     * @param address
-     */
-    static async fillAndCreate(token) {
-        const id = TokenService.hashId(token);
-        const filledData = await TokenService.fetchOnChain({ address: token.address, chainId: token.chainId });
-        try {
-            const coingeckoToken = await CoingeckoService.findList();
-            const coingeckoTokenData = coingeckoToken.find(t => t.symbol === filledData.symbol && t.name === filledData.name);
-            if (!!coingeckoTokenData) {
-                await CoingeckoService.createPriceSourceForSymbolIfMissing(filledData.symbol, coingeckoTokenData.id);
-                if (!token.icon || token.icon === "") {
-                    const coingeckoIcon = (await CoingeckoService.findMarkets([coingeckoTokenData.id]))[0].image;
-                    token.icon = coingeckoIcon;
-                    log.info(`completed with coingecko icon: ${coingeckoIcon}`);
-                }
-            }
-        }
-        catch {
-            log.warn("coingecko token autocompletion failed");
-        }
-        return await TokenRepository.upsert({ ...filledData, ...token, id });
-    }
-}

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

@@ -1,30 +0,0 @@
-import { record } from "@elysiajs/opentelemetry";
-export class TracerService {
-    static createTracedProxy(target, serviceName) {
-        return new Proxy(target, {
-            get(target, property, receiver) {
-                const originalMethod = Reflect.get(target, property, receiver);
-                if (typeof originalMethod === "function") {
-                    return function (...args) {
-                        return record(`${serviceName}.${property}`, async (span) => {
-                            // Add relevant attributes to the span
-                            span.setAttribute("service.name", serviceName);
-                            span.setAttribute("service.method", property);
-                            try {
-                                const result = await originalMethod.apply(this, args);
-                                return result;
-                            }
-                            catch (error) {
-                                span.setStatus({ code: 2 }); // OpenTelemetry StatusCode.ERROR
-                                span.setAttribute("error.message", error.message);
-                                span.recordException(error);
-                                throw error;
-                            }
-                        });
-                    };
-                }
-                return originalMethod;
-            },
-        });
-    }
-}

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

@@ -1,20 +0,0 @@
-import { throwOnInvalidRequiredAddress } from "@/utils/throw";
-import Elysia from "elysia";
-import { UserUniqueDto } from "../user/user.model";
-import { TurtleService } from "./turtle.service";
-// ─── Claim Controller ───────────────────────────────────────────────────────
-export const TurtleController = new Elysia({ prefix: "/turtle", detail: { tags: ["Turtle"] } })
-    .get("/tac/total", async () => await TurtleService.getTotalDistributed(), {
-    detail: {
-        description: "Get total TAC distributed and the associated breakdown",
-    },
-})
-    .get("/tac/:address", async ({ params }) => await TurtleService.getUserData(params), {
-    params: UserUniqueDto,
-    beforeHandle: ({ params }) => {
-        params.address = throwOnInvalidRequiredAddress(params.address);
-    },
-    detail: {
-        description: "Get the max balance and balance of the user for its turtle vaults",
-    },
-});

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

@@ -1,40 +0,0 @@
-import request, { gql } from "graphql-request";
-const TURTLE_SUBGRAPH_URL = "https://api.goldsky.com/api/public/project_cltpyx1eh5g5v01xi0a5h5xea/subgraphs/merkl-tacTurtle-mainnet/prod/gn";
-export class TurtleRepository {
-    static async fetchUserBalances(address) {
-        try {
-            return (await request(TURTLE_SUBGRAPH_URL, gql `query UserBalances($where: UserBalance_filter) {
-            userBalances(where: $where) {
-              balance
-              maxBalance
-              tokenSymbol
-              token
-              turtleDepositBonus
-              user
-            }
-          }
-    `, {
-                where: {
-                    user: address.toLowerCase(),
-                },
-            })).userBalances;
-        }
-        catch {
-            return [];
-        }
-    }
-    static async fetchTotals() {
-        try {
-            return (await request(TURTLE_SUBGRAPH_URL, gql `query TurtleDistributeds {
-            turtleDistributeds {
-              amount
-              id
-            }
-          }
-    `, {})).turtleDistributeds;
-        }
-        catch {
-            return [];
-        }
-    }
-}

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

@@ -1,28 +0,0 @@
-import { TurtleRepository } from "./turtle.repository";
-export class TurtleService {
-    // ─── Get Turtle User data ─────────────────────────────────────────────────
-    static async getUserData(params) {
-        const userBalances = await TurtleRepository.fetchUserBalances(params.address);
-        return userBalances.reduce((acc, userBalance) => {
-            acc[userBalance.token] = {
-                vaultSymbol: userBalance.tokenSymbol,
-                balance: Number(userBalance.balance),
-                maxBalance: Number(userBalance.maxBalance),
-                turtle: Number(userBalance.turtleDepositBonus),
-            };
-            return acc;
-        }, {});
-    }
-    // ─── Get Total Turtle Distributed ─────────────────────────────────────────
-    static async getTotalDistributed() {
-        const totals = await TurtleRepository.fetchTotals();
-        return totals.reduce((acc, item) => {
-            if (item.id === "total") {
-                acc.total = Number(item.amount);
-                return acc;
-            }
-            acc.breakdown[item.id] = Number(item.amount);
-            return acc;
-        }, { total: 0, breakdown: {} });
-    }
-}

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

@@ -1,13 +0,0 @@
-import { TvlType } from "@db/api";
-import { t } from "elysia";
-// ─── Dtos ────────────────────────────────────────────────────────────────────
-export const TvlBreakdownResourceDto = t.Object({
-    identifier: t.String(),
-    type: t.Enum(TvlType),
-    value: t.Number(),
-});
-export const TvlRecordResourceDto = t.Object({
-    total: t.Number(),
-    timestamp: t.Union([t.BigInt(), t.String()]),
-    breakdowns: t.Array(TvlBreakdownResourceDto),
-});

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

@@ -1,63 +0,0 @@
-import { TvlType } from "@db/api";
-import { Campaign } from "@sdk";
-import moment from "moment";
-export class TvlService {
-    static hashId(opportunityId, timestamp) {
-        return Bun.hash(`${opportunityId}${timestamp}`).toString();
-    }
-    /**
-     * @deprecated
-     */
-    static extractFromDynamicData(type, dynamicData, timestamp = BigInt(moment().unix())) {
-        const typesWithoutApr = [Campaign.INVALID, Campaign.JSON_AIRDROP, Campaign.ERC20_SNAPSHOT];
-        if (typesWithoutApr.includes(type))
-            return { timestamp, total: 0, breakdowns: [] };
-        /**
-         *  Merge dynamic data and take the max tvl encountered
-         * @dev Useful if campaigns have different hooks or blacklists and so different target tvl
-         */
-        const opportunitySummary = dynamicData.reduce((merged, c) => {
-            const res = Object.assign(merged, c);
-            const campaignTvl = c?.tvl ?? 0;
-            if (campaignTvl > (merged?.tvl ?? 0)) {
-                res.tvl = campaignTvl;
-            }
-            return res;
-        }, {});
-        let breakdowns = [];
-        if (type === Campaign.CLAMM) {
-            breakdowns = [
-                {
-                    identifier: opportunitySummary.campaignParameters.token0,
-                    type: TvlType.TOKEN,
-                    value: Number.isNaN(Number(opportunitySummary.poolBalanceToken0))
-                        ? 0
-                        : Number(opportunitySummary.poolBalanceToken0),
-                },
-                {
-                    identifier: opportunitySummary.campaignParameters.token1,
-                    type: TvlType.TOKEN,
-                    value: Number.isNaN(Number(opportunitySummary.poolBalanceToken1))
-                        ? 0
-                        : Number(opportunitySummary.poolBalanceToken1),
-                },
-            ];
-            for (const campaign of dynamicData) {
-                if (campaign.forwarders) {
-                    for (const forwarder of campaign.forwarders) {
-                        breakdowns.push({
-                            identifier: forwarder.label,
-                            type: TvlType.PROTOCOL,
-                            value: Number.isNaN(Number(forwarder.almTVL)) ? 0 : Number(forwarder.almTVL),
-                        });
-                    }
-                }
-            }
-        }
-        return {
-            timestamp,
-            total: Number.isNaN(Number(opportunitySummary.tvl)) ? 0 : Number(opportunitySummary.tvl),
-            breakdowns,
-        };
-    }
-}