@merkl/api 0.9.15

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

@@ -0,0 +1,422 @@
+import { HttpError } from "@/errors";
+import { getTokensListWithCache } from "@/libs/getTokensList";
+import { getOnlyUserBalance } from "@/libs/tokens/balances";
+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, bigIntToNumber, } from "@sdk";
+import { getAddress, parseUnits } from "viem";
+import { BucketService } from "../bucket/bucket.service";
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
+import { PriceService } from "../price";
+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 TokenService.findMany({ chainId: chainId, verified: true });
+        const nativeTokens = (await TokenService.findMany({ chainId: 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 = await TokenRepository.getTokenInfo(token);
+        return {
+            chainId: token.chainId,
+            address: token.address,
+            icon: "",
+            ...Object.assign({
+                name: "unknown",
+                decimals: 18,
+                symbol: "UNKNOWN",
+                verified: false,
+                isTest: false,
+                isPoint: 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));
+        log.info(`found ${priceSources.length} tokens with missing icons on coingecko.`);
+        // 4 - Loop through each and try to get the icon
+        for (const priceSource of priceSources) {
+            const coingeckoTicker = priceSource.args?.ticker;
+            if (!!coingeckoTicker) {
+                try {
+                    const icon = await TokenRepository.fetchIconFromCoingeckoTicker(coingeckoTicker);
+                    if (icon.length > 0) {
+                        const res = await TokenRepository.updateMissingIconsPerSymbol(priceSource.symbol, icon);
+                        log.info(`updated ${res.count} tokens with icon ${icon} ${priceSource.symbol}`);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                // Avoid rate limits, wait 1 min
+                await new Promise(resolve => setTimeout(resolve, 60_000));
+            }
+        }
+    }
+    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);
+    }
+    /**
+     * 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);
+    }
+    static async getPrice(query) {
+        const tokensFound = (await TokenRepository.findMany(query)).map(TokenService.format);
+        if (tokensFound.length === 0) {
+            throw new Error("Token not found");
+        }
+        // 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 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(tokenAmountMap) {
+        const ids = Array.from(tokenAmountMap.keys());
+        const tokens = await TokenService.findMany({ id: ids });
+        if (tokens.length !== ids.length)
+            throw new Error("Cannot find one or more token(s) in the database.");
+        let totalValue = 0;
+        for (const token of tokens)
+            totalValue += (bigIntToNumber(tokenAmountMap.get(token.id) ?? 0n, token.decimals) ?? 0) * (token.price ?? 0);
+        return totalValue;
+    }
+    /**
+     * 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) {
+                if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2025") {
+                    const newToken = Object.assign(await TokenService.fetchOnChain(token), { id });
+                    if (!newToken) {
+                        throw new HttpError(`Failed to fetch on-chain data for token ${token.address} on chain ${token.chainId}).`);
+                    }
+                    return TokenService.format(await TokenRepository.upsert(newToken));
+                }
+            }
+            throw new HttpError(`Failed to fetch or create token ${token.address} on chain ${token.chainId}.`);
+        }));
+    }
+    static async getValidRewardTokens(chainId) {
+        return await CacheService.wrap(TTLPresets.MIN_5, async (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(),
+                };
+            });
+        }, chainId);
+    }
+    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 bucket = new BucketService(`merkl-${env}-tokens`, `angle-${env}-1`);
+        const properties = body.data.properties;
+        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].split("+")[0];
+        const address = throwOnInvalidRequiredAddress(properties.Address.rich_text[0].plain_text);
+        const chainId = properties["Chain ID"].number;
+        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(); // Unknown type error here probably due to bun/types
+        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 bucket.pushRaw(`${chainId}/${address}.${extension}`, byteArray, {
+                type: mimeType,
+                isPublic: true,
+            });
+            token.icon = `${process.env.GCS_ENDPOINT}/merkl-${env}-tokens/${chainId}/${address}.${extension}`;
+        }
+        catch (err) {
+            console.error(err);
+            token.icon = icon;
+        }
+        if (coingeckoApiId) {
+            try {
+                await PriceService.createPriceSource({
+                    method: "COINGECKO",
+                    symbol: token.symbol,
+                    args: { ticker: coingeckoApiId },
+                });
+            }
+            catch (err) {
+                console.error("Failed to create price source.");
+                console.error(err);
+            }
+        }
+        return await TokenService.update(token.id, {
+            icon: token.icon,
+            displaySymbol: displaySymbol && displaySymbol !== "" ? displaySymbol : token.symbol,
+            name: token.name,
+            verified: isVerified,
+        });
+    }
+    /**
+     * Fetches symbol, address, decimals and creates token on database
+     * @param chainId
+     * @param address
+     */
+    static async fillAndCreate(token) {
+        try {
+            const id = TokenService.hashId(token);
+            const filledData = await TokenService.fetchOnChain({ address: token.address, chainId: token.chainId });
+            return await TokenRepository.upsert({ ...filledData, ...token, id });
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    /**
+     * @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) { }
+            }
+        }
+    }
+}

package/dist/src/modules/v4/tracer/index.d.ts

@@ -0,0 +1 @@
+export * from "./tracer.service";

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

@@ -0,0 +1 @@
+export * from "./tracer.service";

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

@@ -0,0 +1,3 @@
+export declare class TracerService {
+    static createTracedProxy<T extends object>(target: T, serviceName: string): T;
+}

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

@@ -0,0 +1,30 @@
+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/tvl/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./tvl.model";
+export * from "./tvl.service";

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

@@ -0,0 +1,2 @@
+export * from "./tvl.model";
+export * from "./tvl.service";

package/dist/src/modules/v4/tvl/tvl.model.d.ts

@@ -0,0 +1,39 @@
+import type { Resource } from "@/modules/v4/prisma";
+/**
+ * Tvl Record
+ * @description Describes one tvl snapshot for an opportunity
+ * @see {@link Resource}
+ */
+export type TvlRecord = Resource<"TVLRecord", "id" | "opportunityId", {
+    breakdowns: TvlBreakdown["model"][];
+}>;
+/**
+ * Tvl Breakdown
+ * @description Describes one tvl fraction of record
+ * @see {@link Resource}
+ */
+export type TvlBreakdown = Resource<"TVLBreakdown", "id" | "tvlRecordId">;
+export declare const TvlBreakdownResourceDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TNumber;
+    type: import("@sinclair/typebox").TEnum<{
+        TOKEN: "TOKEN";
+        PROTOCOL: "PROTOCOL";
+    }>;
+    identifier: import("@sinclair/typebox").TString;
+    value: import("@sinclair/typebox").TNumber;
+    tvlRecordId: import("@sinclair/typebox").TString;
+}>;
+export declare const TvlRecordResourceDto: import("@sinclair/typebox").TObject<{
+    total: import("@sinclair/typebox").TNumber;
+    timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
+    breakdowns: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TNumber;
+        type: import("@sinclair/typebox").TEnum<{
+            TOKEN: "TOKEN";
+            PROTOCOL: "PROTOCOL";
+        }>;
+        identifier: import("@sinclair/typebox").TString;
+        value: import("@sinclair/typebox").TNumber;
+        tvlRecordId: import("@sinclair/typebox").TString;
+    }>>;
+}>;

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

@@ -0,0 +1,15 @@
+import { TvlType } from "@db/api";
+import { t } from "elysia";
+// ─── Dtos ────────────────────────────────────────────────────────────────────
+export const TvlBreakdownResourceDto = t.Object({
+    id: t.Number(),
+    type: t.Enum(TvlType),
+    identifier: t.String(),
+    value: t.Number(),
+    tvlRecordId: t.String(),
+});
+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.d.ts

@@ -0,0 +1,6 @@
+import { Campaign, type CampaignDynamicData } from "@sdk";
+import type { TvlRecord } from "./tvl.model";
+export declare abstract class TvlService {
+    static hashId(opportunityId: string, timestamp: bigint): string;
+    static extractFromDynamicData<C extends Campaign>(type: C, dynamicData: CampaignDynamicData<C>[], timestamp?: bigint): TvlRecord["model"];
+}

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

@@ -0,0 +1,49 @@
+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();
+    }
+    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: [] };
+        const opportunitySummary = dynamicData.reduce((merged, c) => Object.assign(merged, c), {});
+        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,
+        };
+    }
+}

package/dist/src/modules/v4/uniswapV4/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./uniswapV4.controller";
+export * from "./uniswapV4.service";
+export * from "./uniswapV4.repository";
+export * from "./uniswapV4.model";

package/dist/src/modules/v4/uniswapV4/index.js

@@ -0,0 +1,4 @@
+export * from "./uniswapV4.controller";
+export * from "./uniswapV4.service";
+export * from "./uniswapV4.repository";
+export * from "./uniswapV4.model";

package/dist/src/modules/v4/uniswapV4/uniswapV4.controller.d.ts

@@ -0,0 +1,53 @@
+import Elysia from "elysia";
+export declare const uniswapV4Controller: Elysia<"uniswap-v4", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    "uniswap-v4": {
+        pools: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    chainId: number;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        [x: string]: {
+                            poolId: string;
+                            poolKey: {
+                                hooks: string;
+                                fee: number;
+                                tickSpacing: number;
+                                currency0: string;
+                                currency1: string;
+                            };
+                            decimalsCurrency0: number;
+                            decimalsCurrency1: number;
+                            symbolCurrency0: string;
+                            symbolCurrency1: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,12 @@
+import Elysia, { t } from "elysia";
+import { UniswapV4Service } from "./uniswapV4.service";
+export const uniswapV4Controller = new Elysia({
+    prefix: "uniswap-v4",
+    detail: { tags: ["Uniswap V4"], hide: true },
+}).get("/pools", async ({ query }) => {
+    return await UniswapV4Service.getPoolsByChain(query.chainId);
+}, {
+    query: t.Object({
+        chainId: t.Numeric(),
+    }),
+});