@merkl/api 0.10.128 → 0.10.130

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

@@ -0,0 +1,268 @@
+import { getTokensListWithCache } from "../../../libs/getTokensList";
+import { getOnlyUserBalance } from "../../../libs/tokens/balances";
+import { executeSimple } from "../../../utils/execute";
+import { log } from "../../../utils/logger";
+import { apiDbClient } from "../../../utils/prisma";
+import { Prisma } from "../../../../database/api/.generated";
+import { NETWORK_LABELS, bigIntToNumber } from "@sdk";
+import { parseUnits } from "viem";
+import { TokenRepository } from "./token.repository";
+export class TokenService {
+    static hashId(token) {
+        return Bun.hash(`${token.chainId}${token.address}`).toString();
+    }
+    /**
+     * Fetches balances of provided tokens
+     */
+    static async fetchBalances(chainId, userAddress, tokens) {
+        const balances = await executeSimple(chainId, getOnlyUserBalance(chainId, userAddress, tokens.map(t => t.address)));
+        const tokensWithBalances = tokens.map(t => {
+            const balance = 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.getManyOrCreate(addresses?.map(address => ({ chainId, address })));
+        return TokenService.fetchBalances(chainId, userAddress, tokens.filter(t => t !== undefined));
+    }
+    /**
+     * 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 fetchVerifiedBalances(chainId, userAddress, additionalTokenAddresses) {
+        const verifiedTokens = await TokenService.findMany({ chainId: chainId, verified: true });
+        const additionalTokens = !!additionalTokenAddresses?.length
+            ? await TokenService.getManyOrCreate(additionalTokenAddresses?.map(address => ({ chainId, address })))
+            : [];
+        const allTokens = verifiedTokens.concat(additionalTokens.filter(t => t !== undefined));
+        return TokenService.fetchBalances(chainId, userAddress, allTokens);
+    }
+    static async fetchOnChain(token) {
+        const onchainData = await TokenRepository.getTokenInfo(token);
+        //TODO: find a way to get the icon
+        return {
+            chainId: token.chainId,
+            address: token.address,
+            icon: "",
+            ...Object.assign({ name: "unknown", decimals: 18, symbol: "UNKNOWN", verified: 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);
+        }
+    }
+    /**
+     * 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,
+                        });
+                        log.local(`Token created: ${res?.symbol} on ${NETWORK_LABELS[Number.parseInt(chain)]}`);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                    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,
+                        });
+                        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) { }
+            }
+        }
+    }
+    /**
+     * Create token on database
+     * @param chainId
+     * @param address
+     */
+    static async create(token) {
+        const id = TokenService.hashId(token);
+        return TokenRepository.upsert({ ...token, id });
+    }
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static async findUniqueOrThrow(token) {
+        return await TokenRepository.findUniqueOrThrow(TokenService.hashId({ chainId: token.chainId, address: token.address }));
+    }
+    /**
+     * Get the list of tokens satisfying the query
+     * @param query
+     * @returns A list of tokens
+     */
+    static async findMany(query) {
+        return await TokenRepository.findMany(query);
+    }
+    /**
+     * 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.getManyOrCreate(tokenAmounts.map(({ address, chainId }) => ({ address, chainId })));
+        return tokenAmounts.reduce((sum, { amount, address, chainId }) => {
+            const token = tokens
+                .filter(t => t !== undefined)
+                .find(({ address: addr, chainId: chain }) => addr === address && chainId === chain);
+            if (!token)
+                return sum;
+            const value = (bigIntToNumber(amount, token.decimals) ?? 0) * (token.price ?? 0);
+            return sum + value;
+        }, 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 getManyOrCreate(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 = await TokenService.fetchOnChain(token);
+                    if (!newToken)
+                        return;
+                    return await TokenRepository.upsert({ ...newToken, id });
+                }
+            }
+        }));
+    }
+}

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.controller.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,49 @@
+import { TvlType } from "../../../../database/api/.generated";
+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.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.js

@@ -0,0 +1,11 @@
+import Elysia, { t } from "elysia";
+import { UniswapV4Service } from "./uniswapV4.service";
+export const uniswapV4Controller = new Elysia().group("uniswapV4", app => {
+    return app.get("/pools", async ({ query }) => {
+        return await UniswapV4Service.getPoolsByChain(query.chainId);
+    }, {
+        query: t.Object({
+            chainId: t.Numeric(),
+        }),
+    });
+});

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

@@ -0,0 +1,17 @@
+import { t } from "elysia";
+const UniswapV4PoolKeyDto = t.Object({
+    currency0: t.String(),
+    currency1: t.String(),
+    fee: t.Numeric(),
+    tickSpacing: t.Numeric(),
+    hooks: t.String(),
+});
+const UniswapV4PoolDto = t.Object({
+    poolKey: UniswapV4PoolKeyDto,
+    poolId: t.String(),
+    decimalsCurrency0: t.Numeric(),
+    decimalsCurrency1: t.Numeric(),
+    symbolCurrency0: t.String(),
+    symbolCurrency1: t.String(),
+});
+export const UniswapV4PoolsDto = t.Record(t.String(), UniswapV4PoolDto);

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

@@ -0,0 +1,2 @@
+export class UniswapV4Repository {
+}

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

@@ -0,0 +1,73 @@
+import { safeFetchLogs } from "../../../libs/campaigns/utils/fetchLogs";
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { providers } from "../../../utils/providers";
+import { ERC20Interface, UniswapV4PoolManager__factory } from "@sdk";
+import { utils } from "ethers";
+export const PoolManagerInterface = UniswapV4PoolManager__factory.createInterface();
+export class UniswapV4Service {
+    static async getPoolsByChain(chainId) {
+        const lastBlock = await providers[chainId].getBlockNumber();
+        const logs = await safeFetchLogs(chainId, [PoolManagerInterface.getEventTopic("Initialize")], ["0xE8E23e97Fa135823143d6b9Cba9c699040D51F70"], 0, lastBlock);
+        const poolData = [];
+        const calls = [];
+        for (const log of logs) {
+            const poolId = utils.defaultAbiCoder.decode(["bytes32"], log.topics[1])[0];
+            const currency0 = utils.defaultAbiCoder.decode(["address"], log.topics[2])[0];
+            const currency1 = utils.defaultAbiCoder.decode(["address"], log.topics[3])[0];
+            const [_indexedPoolId, _indexedCurrency0, _indexedCurrency1, fee, tickSpacing, hooks, sqrtPriceX98, tick] = PoolManagerInterface.decodeEventLog("Initialize", log.data, log.topics);
+            poolData.push({
+                poolId,
+                poolKey: {
+                    currency0,
+                    currency1,
+                    fee,
+                    tickSpacing,
+                    hooks,
+                },
+            });
+            calls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("symbol"),
+                target: currency0,
+            }, {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("decimals"),
+                target: currency0,
+            }, {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("symbol"),
+                target: currency1,
+            }, {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("decimals"),
+                target: currency1,
+            });
+        }
+        const result = await batchMulticallCallWithRetry(chainId, { calls });
+        const res = {};
+        for (const [index, pool] of poolData.entries()) {
+            let symbolCurrency0 = "";
+            let decimalsCurrency0 = 0;
+            let symbolCurrency1 = "";
+            let decimalsCurrency1 = 0;
+            try {
+                symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", result[index * 4].returnData)[0];
+            }
+            catch { }
+            try {
+                decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", result[index * 4 + 1].returnData)[0];
+            }
+            catch { }
+            try {
+                symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", result[index * 4 + 2].returnData)[0];
+            }
+            catch { }
+            try {
+                decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", result[index * 4 + 3].returnData)[0];
+            }
+            catch { }
+            res[pool.poolId] = { ...pool, symbolCurrency0, decimalsCurrency0, symbolCurrency1, decimalsCurrency1 };
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from "./user.controller";
+export * from "./user.model";
+export * from "./user.service";

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

@@ -0,0 +1,69 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
+import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../../utils/throw";
+import { Elysia } from "elysia";
+import { ChainArrayDto } from "../chain";
+import { RewardService } from "../reward";
+import { GetManyUserQuery, UpdateUserTagsDto, UserDto, UserUniqueDto } from "./user.model";
+import { UserService } from "./user.service";
+// ─── Users Controller ────────────────────────────────────────────────────────
+export const UserController = new Elysia({ prefix: "/users", detail: { tags: ["Users"] } })
+    // ─── Get Many Users ──────────────────────────────────────────────────
+    .get("/", async ({ query }) => {
+    return await UserService.findMany(query);
+}, { query: GetManyUserQuery })
+    // ─── Get All Tagged Users ─────────────────────────────────────────────
+    .get("/tags", async () => {
+    return await UserService.findManyWithTags();
+}, { headers: AuthorizationHeadersDto, beforeHandle: BackOfficeGuard })
+    // ─── Get A User By Address ───────────────────────────────────────────
+    .get("/:address", async ({ params }) => {
+    return await UserService.findUnique(params.address);
+})
+    // ─── Get User's Rewards With Breakdown And Details for our FE ────────
+    .get(
+// TODO: redefine as /:address/rewards/breakdowns to follow REST standard (URI components should be nouns)
+"/:address/rewards/full", async ({ params }) => {
+    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, true);
+    return RewardService.splitRewardsBreakdownByOpportunity(rewardsByChain);
+}, {
+    params: UserUniqueDto,
+    beforeHandle: ({ params }) => {
+        params.address = throwOnInvalidRequiredAddress(params.address);
+    },
+})
+    // ─── Get User's Rewards With Breakdown ──────────────────────────────
+    .get("/:address/rewards", async ({ params, query }) => {
+    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, false, typeof query.chainId === "number" ? [query.chainId] : query.chainId);
+    return RewardService.removeOpportunityFromRewardBreakdown(rewardsByChain);
+}, {
+    params: UserUniqueDto,
+    query: ChainArrayDto,
+    beforeHandle: ({ query, params }) => {
+        params.address = throwOnInvalidRequiredAddress(params.address);
+        if (typeof query.chainId === "number") {
+            throwOnUnsupportedChainId(query.chainId);
+        }
+        else {
+            for (const chainId of query.chainId) {
+                throwOnUnsupportedChainId(chainId);
+            }
+        }
+    },
+})
+    // ─── Create A User ───────────────────────────────────────────────────
+    .post("/", async ({ body }) => {
+    return await UserService.create(body);
+}, { headers: AuthorizationHeadersDto, body: UserDto, beforeHandle: BackOfficeGuard })
+    // ─── Sync Creator Tags with Engine DB ─────────────────────────────────
+    .post("/sync", async () => {
+    return await UserService.syncTags();
+}, { headers: AuthorizationHeadersDto, beforeHandle: BackOfficeGuard })
+    // ─── Update User's Tags ──────────────────────────────────────────────
+    .patch("/:address/tags", async ({ params, body }) => {
+    return await UserService.updateTags(params.address, body.tags);
+}, {
+    headers: AuthorizationHeadersDto,
+    params: UserUniqueDto,
+    body: UpdateUserTagsDto,
+    beforeHandle: BackOfficeGuard,
+});

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

@@ -0,0 +1,18 @@
+import { t } from "elysia";
+// ─── Dtos ────────────────────────────────────────────────────────────────────
+export const UserUniqueDto = t.Object({
+    address: t.String(),
+});
+export const UserDto = t.Object({
+    address: t.String(),
+    tags: t.Array(t.String()),
+});
+export const GetManyUserQuery = t.Object({
+    address: t.Optional(t.String()),
+    tags: t.Optional(t.Array(t.String())),
+    page: t.Optional(t.Number()),
+    items: t.Optional(t.Number()),
+});
+export const UpdateUserTagsDto = t.Object({
+    tags: t.Array(t.String()),
+});

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

@@ -0,0 +1,38 @@
+import { apiDbClient } from "../../../utils/prisma";
+// ─── Users Repository ────────────────────────────────────────────────────────
+export class UserRepository {
+    static async findUnique(address) {
+        return await apiDbClient.user.findUnique({ where: { address } });
+    }
+    static async findMany(query) {
+        const { page: _page, items: _items, ...filters } = query;
+        const page = _page ? _page : 0;
+        const items = _items ? _items : 20;
+        return await apiDbClient.user.findMany({
+            take: items,
+            skip: page * items,
+            where: {
+                address: filters.address ? filters.address : undefined,
+                tags: filters.tags ? { hasEvery: filters.tags } : undefined,
+            },
+        });
+    }
+    static async findManyWithTags() {
+        return await apiDbClient.user.findMany({
+            where: {
+                tags: {
+                    isEmpty: false,
+                },
+            },
+        });
+    }
+    static async create(user) {
+        return await apiDbClient.user.create({ data: user });
+    }
+    static async createMany(users) {
+        return await apiDbClient.user.createMany({ data: users, skipDuplicates: true });
+    }
+    static async updateTags(address, tags) {
+        return await apiDbClient.user.update({ where: { address }, data: { tags } });
+    }
+}

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

@@ -0,0 +1,50 @@
+import { log } from "../../../utils/logger";
+import { engineDbClient } from "../../../utils/prisma";
+import { UserRepository } from "./user.repository";
+// ─── Users Services ──────────────────────────────────────────────────────────
+export class UserService {
+    static async findUnique(address) {
+        return await UserRepository.findUnique(address);
+    }
+    static async findMany(query) {
+        return await UserRepository.findMany(query);
+    }
+    static async findManyWithTags() {
+        return await UserRepository.findManyWithTags();
+    }
+    static async create(user) {
+        return await UserRepository.create(user);
+    }
+    static async createMany(users) {
+        return await UserRepository.createMany(users);
+    }
+    static async updateTags(user, tags) {
+        return await UserRepository.updateTags(user, tags);
+    }
+    static async syncTags() {
+        // 1 - engine -> api db
+        const creatorTags = await engineDbClient.campaignCreators.findMany();
+        log.info(`syncing ${creatorTags.length} creator tags`);
+        await UserRepository.createMany(creatorTags.map(tag => {
+            return {
+                address: tag.address,
+                tags: [],
+            };
+        }));
+        for (const tag of creatorTags) {
+            await UserRepository.updateTags(tag.address, tag.tags.split(",").map(tag => tag.trim()));
+        }
+        // 2 - api -> engine db
+        const apiUsers = await UserRepository.findManyWithTags();
+        for (const tag of creatorTags) {
+            if (creatorTags.findIndex(t => t.address === tag.address) === -1) {
+                await engineDbClient.campaignCreators.create({
+                    data: {
+                        address: tag.address,
+                        tags: apiUsers.find(u => u.address === tag.address)?.tags.join(",") || "",
+                    },
+                });
+            }
+        }
+    }
+}

package/dist/src/plugins/error-handling.plugin.js

@@ -0,0 +1,28 @@
+import { BadRequestError, ConflictError, HttpError, NotFoundError, UnauthorizedError } from "../errors";
+import { log } from "../utils/logger";
+import Elysia from "elysia";
+// ─── Error Handler Plugin ────────────────────────────────────────────────────
+export const ErrorHandler = new Elysia()
+    // ─── Error Types ─────────────────────────────────────────────────────
+    .error({
+    HttpError,
+    BadRequestError,
+    ConflictError,
+    NotFoundError,
+    UnauthorizedError,
+})
+    // ─── Error Handling ──────────────────────────────────────────────────
+    .onError(({ code, error, set }) => {
+    if (code === "HttpError") {
+        log.error("HttpError", error);
+        set.status = error.httpCode;
+        set.headers["content-type"] = "application/json";
+        return {
+            name: error.name,
+            message: error.message,
+            info: error.info,
+        };
+    }
+    log.error("Unknown error", error);
+    return error;
+});