@merkl/api 0.9.15

package/dist/src/engine/opportunityMetadata/implementations/Morpho.js

@@ -0,0 +1,21 @@
+import { OpportunityAction } from "@db/api";
+import { BN2Number } from "@sdk";
+export class MorphoMetadata {
+    async build(computeChainId, params, subType) {
+        const morphoParams = params;
+        const market = `${morphoParams.symbolLoanToken}/${morphoParams.symbolBorrowToken} ${morphoParams?.LLTV && BN2Number(morphoParams?.LLTV, 16)}%`;
+        const subtypes = [
+            { name: `Deposit in ${morphoParams.nameTargetToken} - Metamorpho`, action: OpportunityAction.LEND },
+            { name: `Supply ${morphoParams.symbolLoanToken} on ${market}`, action: OpportunityAction.LEND },
+            { name: `Borrow ${morphoParams.symbolLoanToken} on ${market}`, action: OpportunityAction.BORROW },
+            { name: `Lend ${morphoParams.symbolBorrowToken} on ${market}`, action: OpportunityAction.LEND },
+        ];
+        const subtype = subtypes[subType];
+        return {
+            action: subtype.action,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            name: subtype.name,
+            mainProtocol: "morpho",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Radiant.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.RADIANT;
+export declare class RadiantMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Radiant.js

@@ -0,0 +1,11 @@
+import { OpportunityAction } from "@db/api";
+export class RadiantMetadata {
+    async build(computeChainId, params, subType) {
+        return {
+            action: subType <= 1 ? OpportunityAction.LEND : OpportunityAction.BORROW,
+            name: [subType <= 1 ? "Lend" : "Borrow", params.symbolTargetToken].join(" "),
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: "radiant",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Silo.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.SILO;
+export declare class SiloMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Silo.js

@@ -0,0 +1,15 @@
+import { OpportunityAction } from "@db/api";
+export class SiloMetadata {
+    async build(computeChainId, params, subType) {
+        let suffix = ["Deposit", "Protected Deposit", "Debt"][subType];
+        const assetSymbol = params.symbolTargetToken;
+        if (params.forwarders.length === 1 && assetSymbol)
+            suffix += ` (${assetSymbol} Market)`;
+        return {
+            action: subType <= 1 ? OpportunityAction.LEND : OpportunityAction.BORROW,
+            name: [subType <= 1 ? "Lend" : "Borrow", params.symbolTargetToken, suffix].join(" "),
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: "silo",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/UniswapV4.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.UNISWAP_V4;
+export declare class UniswapV4Metadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        name: string;
+        action: "POOL";
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/UniswapV4.js

@@ -0,0 +1,28 @@
+import { OpportunityAction } from "@db/api";
+export class UniswapV4Metadata {
+    async build(computeChainId, params, _subType) {
+        const whitelistNameString = "";
+        //   if (params.whitelist.length > 0) {
+        //     for (const whitelist of params.whitelist) {
+        //       if (whitelistNameString.length > 0) {
+        //         whitelistNameString += "or";
+        //       }
+        //       const forwarder = params.forwarders.find(x => getAddress(x.sender) === getAddress(whitelist));
+        //       const forwarderType = (forwarder as CLAMMForwarder)?.type;
+        //       const forwarderName = !!forwarderType ? almName(forwarderType) : null;
+        //       if (!!forwarderName) {
+        //         whitelistNameString += ` ${forwarderName} `;
+        //       }
+        //     }
+        //   }
+        return {
+            name: `Provide liquidity to ${whitelistNameString} UniswapV4 ${params.symbolCurrency0}-${params.symbolCurrency1}${params.lpFee ? ` ${params.lpFee / 10_000}%` : ""}`,
+            action: OpportunityAction.POOL,
+            tokens: [
+                { chainId: computeChainId, address: params.currency0 },
+                { chainId: computeChainId, address: params.currency1 },
+            ],
+            mainProtocol: "uniswap",
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/Vest.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.VEST;
+export declare class VestMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, _params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: string;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/Vest.js

@@ -0,0 +1,12 @@
+import { VEST_TOKEN } from "@/engine/dynamicData/implementations/Vest";
+import { OpportunityAction } from "@db/api";
+export class VestMetadata {
+    async build(computeChainId, _params, _subType) {
+        return {
+            action: OpportunityAction.LEND,
+            name: ["Vest", "supply", "treasury"].join(" "),
+            tokens: [{ chainId: computeChainId, address: VEST_TOKEN }],
+            mainProtocol: "vest",
+        };
+    }
+}

package/dist/src/entities/campaign.d.ts

@@ -0,0 +1,58 @@
+import { Campaign, type CampaignDynamicData, type ChainId, type Opportunity, type OpportunityId } from "@sdk";
+import type { PerChain } from "../types/utils";
+export declare const activeCampaign: <C extends ValidCampaign>(v: CampaignDynamicData<C>) => boolean;
+export declare const inactiveCampaign: <C extends ValidCampaign>(v: CampaignDynamicData<C>) => boolean;
+export declare const removeTestTokens: <C extends ValidCampaign>(v: CampaignDynamicData<C>) => boolean;
+export type ValidCampaign = Exclude<Campaign, Campaign.INVALID>;
+export type Campaigns = {
+    [type_mainParameter: string]: {
+        [campaignId: string]: CampaignDynamicData<Campaign>;
+    };
+};
+export declare function getCampaignsFor(chainIds: ChainId[], filters?: {
+    onlyLive: boolean;
+    types?: number[];
+}): Promise<Campaigns>;
+/**
+ * @returns all opportunityIds in the campaign data
+ */
+export declare function extractIds(campaigns: PerChain<Campaigns>): OpportunityId<ChainId>[];
+/**
+ * @returns the daily price of all rewards from the campaign array
+ */
+export declare function getDailyRewards<C extends ValidCampaign>(campaigns: CampaignDynamicData<C>[], prices: {
+    [token: string]: number;
+}): number;
+/**
+ * @returns the status of an opportunity based on its campaigns
+ */
+export declare function getStatus<C extends ValidCampaign>(campaigns: CampaignDynamicData<C>[]): Opportunity["status"];
+/**
+ * @returns the sum of the APRs from a campaigns array
+ */
+export declare function getApr<C extends Exclude<ValidCampaign, Campaign.ERC20_SNAPSHOT | Campaign.JSON_AIRDROP>>(campaigns: CampaignDynamicData<C>[]): number;
+/**
+ * @returns the sum of the all tags
+ */
+export declare function getTags(campaigns: CampaignDynamicData<ValidCampaign>[]): string[] | undefined;
+/**
+ * @returns all the reward token symbols from a compaign array
+ */
+export declare function getRewardTokenIcons(campaigns: CampaignDynamicData<ValidCampaign>[]): string[];
+/**
+ * @returns the daily reward token symbols from a compaign array
+ */
+export declare function getRewardTokens(campaigns: CampaignDynamicData<ValidCampaign>[]): {
+    symbol: string;
+    address: string;
+    amount: string;
+}[];
+/**
+ * @returns campaigns that match the opportunityIds
+ */
+export declare function splitCampaigns(campaigns: PerChain<Campaigns>, ids: OpportunityId<ChainId>[], showTest?: boolean): {
+    id: OpportunityId<ChainId>;
+    all: CampaignDynamicData<ValidCampaign>[];
+    active: CampaignDynamicData<ValidCampaign>[];
+    inactive: CampaignDynamicData<ValidCampaign>[];
+}[];

package/dist/src/entities/campaign.js

@@ -0,0 +1,136 @@
+import { Redis } from "@/cache";
+import { Campaign, Int256 } from "@sdk";
+import moment from "moment";
+export const activeCampaign = (v) => v.startTimestamp < moment().unix() && v.endTimestamp > moment().unix();
+export const inactiveCampaign = (v) => v.startTimestamp > moment().unix() || v.endTimestamp < moment().unix();
+export const removeTestTokens = (v) => !["aglamerkl", "test"].includes(v.campaignParameters.symbolRewardToken?.toLowerCase());
+export async function getCampaignsFor(chainIds, filters = { onlyLive: false }) {
+    const cachePrefix = filters?.onlyLive ? "LiveCampaigns" : "Campaigns";
+    const cacheKeys = chainIds.map(chain => `${cachePrefix}_${chain}`);
+    return (await Redis.findMany(cacheKeys)).reduce((prev, allData, index) => {
+        if (!!allData) {
+            const chain = chainIds[index];
+            prev[chain] = Object.keys(allData).reduce((acc, curr) => {
+                const [type, mainParameter] = curr.split("_");
+                const campaignType = Number.parseInt(type);
+                if (!filters?.types?.length || filters?.types?.includes(campaignType)) {
+                    acc[`${campaignType}_${mainParameter}`] = allData[curr];
+                }
+                return acc;
+            }, {});
+        }
+        return prev;
+    }, {});
+}
+/**
+ * @returns all opportunityIds in the campaign data
+ */
+export function extractIds(campaigns) {
+    const chains = Object.keys(campaigns).map(n => Number.parseInt(n));
+    return chains.flatMap(chainId => Object.keys(campaigns[chainId] ?? {})?.map(opportunityId => `${chainId}_${opportunityId}`));
+}
+/**
+ * @returns the daily price of all rewards from the campaign array
+ */
+export function getDailyRewards(campaigns, prices) {
+    const rewardPrices = campaigns
+        .map(({ campaignParameters: c, amount, endTimestamp, startTimestamp, campaignType }) => {
+        const isSporadic = [Campaign.ERC20_SNAPSHOT, Campaign.JSON_AIRDROP].includes(campaignType);
+        const timespan = Math.abs(endTimestamp - startTimestamp);
+        let dayspan = isSporadic ? 1 : Math.floor(timespan / (60 * 60 * 24));
+        if (dayspan === 0)
+            dayspan = 1; // If distribution periode < 1 day -> avoid division by 0
+        return [c.symbolRewardToken, Int256.from(amount, c.decimalsRewardToken).div(dayspan)];
+    })
+        .map(([symbol, amount]) => {
+        return Math.max(prices?.[symbol] ?? 0, 0) * (amount?.toNumber() ?? 0);
+    });
+    return rewardPrices?.length > 0 ? rewardPrices.reduce((a, b) => a + b) : 0;
+}
+/**
+ * @returns the status of an opportunity based on its campaigns
+ */
+export function getStatus(campaigns) {
+    const active = campaigns?.filter(activeCampaign);
+    const inactive = campaigns?.filter(inactiveCampaign);
+    if (active?.length)
+        return "live";
+    if (inactive?.some(v => v.startTimestamp > moment().unix()))
+        return "soon";
+    return "past";
+}
+/**
+ * @returns the sum of the APRs from a campaigns array
+ */
+export function getApr(campaigns) {
+    return campaigns.reduce((res, campaign) => res + (campaign.apr ?? 0), 0);
+}
+/**
+ * @returns the sum of the all tags
+ */
+export function getTags(campaigns) {
+    const tags = Array.from(campaigns.reduce((res, campaign) => {
+        campaign.tags?.forEach(tag => {
+            res.add(tag);
+        });
+        return res;
+    }, new Set()));
+    return tags.length === 0 ? undefined : tags;
+}
+/**
+ * @returns all the reward token symbols from a compaign array
+ */
+export function getRewardTokenIcons(campaigns) {
+    const rewardTokens = new Set();
+    campaigns.forEach(({ rewardToken }) => rewardTokens.add(rewardToken));
+    return Array.from(rewardTokens);
+}
+/**
+ * @returns the daily reward token symbols from a compaign array
+ */
+export function getRewardTokens(campaigns) {
+    const rewardTokens = {};
+    campaigns.forEach(({ amount, rewardToken, campaignParameters: { symbolRewardToken: symbol }, ...c }) => {
+        const timespan = Math.abs(c.endTimestamp - c.startTimestamp);
+        const isWithinTimespan = moment().unix() > c.startTimestamp && moment().unix() < c.endTimestamp;
+        const dayspan = Math.max(Math.floor(timespan / (60 * 60 * 24)), 1);
+        const dailyAmount = isWithinTimespan ? BigInt(amount) / BigInt(dayspan) : 0n;
+        if (!rewardTokens[symbol])
+            rewardTokens[symbol] = { amount: dailyAmount, address: rewardToken };
+        else
+            rewardTokens[symbol].amount += dailyAmount;
+    });
+    return Object.entries(rewardTokens).map(([symbol, { amount, address }]) => ({
+        symbol,
+        address,
+        amount: amount.toString(),
+    }));
+}
+/**
+ * @returns campaigns that match the opportunityIds
+ */
+export function splitCampaigns(campaigns, ids, showTest) {
+    if (!campaigns || !ids?.length)
+        return [];
+    const campaignAt = (id) => {
+        const [chainId, type, mainParameter] = id.split("_");
+        return (campaigns?.[chainId]?.[`${type}_${mainParameter}`] ??
+            Object.entries(campaigns[chainId] ?? {}).find(([t_m]) => t_m?.toLowerCase() === id?.toLowerCase())?.[1]);
+    };
+    return ids
+        .filter(id => campaignAt(id) !== undefined)
+        .map(id => {
+        let all = Object.values(campaignAt(id) ?? {});
+        if (!showTest)
+            all = all.filter(removeTestTokens);
+        const active = all?.filter(activeCampaign);
+        const inactive = all?.filter(inactiveCampaign);
+        return {
+            id,
+            all,
+            active,
+            inactive,
+        };
+    })
+        .filter(opportunity => opportunity?.all?.length);
+}

package/dist/src/errors/BadRequest.error.d.ts

@@ -0,0 +1,4 @@
+import { HttpError } from "./HttpError";
+export declare class BadRequestError extends HttpError {
+    constructor(message?: string, legalValues?: string[]);
+}

package/dist/src/errors/BadRequest.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class BadRequestError extends HttpError {
+    constructor(message = "Bad Request", legalValues) {
+        super(message, 400, { legalValues });
+        this.name = "BadRequestError";
+    }
+}

package/dist/src/errors/Conflict.error.d.ts

@@ -0,0 +1,4 @@
+import { HttpError } from "./HttpError";
+export declare class ConflictError extends HttpError {
+    constructor(message?: string);
+}

package/dist/src/errors/Conflict.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class ConflictError extends HttpError {
+    constructor(message = "Conflict") {
+        super(message, 409);
+        this.name = "ConflictError";
+    }
+}

package/dist/src/errors/HttpError.d.ts

@@ -0,0 +1,11 @@
+export declare class HttpError extends Error {
+    code: string;
+    httpCode?: number;
+    info?: any;
+    constructor(message?: string, httpCode?: number, info?: any);
+}
+export declare const HttpErrorDto: import("@sinclair/typebox").TObject<{
+    code: import("@sinclair/typebox").TString;
+    httpCode: import("@sinclair/typebox").TNumber;
+    info: import("@sinclair/typebox").TString;
+}>;

package/dist/src/errors/HttpError.js

@@ -0,0 +1,17 @@
+import { t } from "elysia";
+export class HttpError extends Error {
+    code;
+    httpCode;
+    info;
+    constructor(message = "Internal Server Error", httpCode = 500, info) {
+        super(message);
+        this.code = "HttpError";
+        this.httpCode = httpCode;
+        this.info = info;
+    }
+}
+export const HttpErrorDto = t.Object({
+    code: t.String({ default: "Internal Server Error" }),
+    httpCode: t.Number({ default: 500 }),
+    info: t.String(),
+});

package/dist/src/errors/NotFound.error.d.ts

@@ -0,0 +1,8 @@
+import { HttpError } from "./HttpError";
+export declare class NotFoundError extends HttpError {
+    constructor(message?: string);
+}
+export declare const NotFoundErrorDto: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    message: import("@sinclair/typebox").TString;
+}>;

package/dist/src/errors/NotFound.error.js

@@ -0,0 +1,12 @@
+import { t } from "elysia";
+import { HttpError } from "./HttpError";
+export class NotFoundError extends HttpError {
+    constructor(message = "Not Found") {
+        super(message, 404);
+        this.name = "NotFoundError";
+    }
+}
+export const NotFoundErrorDto = t.Object({
+    name: t.String({ default: "NotFoundError" }),
+    message: t.String({ default: "Not Found" }),
+});

package/dist/src/errors/Opportunity.error.d.ts

@@ -0,0 +1,6 @@
+export declare class OpportunityError extends Error {
+    code: string;
+    httpCode?: number;
+    info?: object;
+    constructor(message: string, name: string, info?: object);
+}

package/dist/src/errors/Opportunity.error.js

@@ -0,0 +1,11 @@
+export class OpportunityError extends Error {
+    code;
+    httpCode;
+    info;
+    constructor(message, name, info) {
+        super(message);
+        this.code = "OpportunityError";
+        this.name = name;
+        this.info = info;
+    }
+}

package/dist/src/errors/Unauthorized.error.d.ts

@@ -0,0 +1,4 @@
+import { HttpError } from "./HttpError";
+export declare class UnauthorizedError extends HttpError {
+    constructor(message?: string);
+}

package/dist/src/errors/Unauthorized.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class UnauthorizedError extends HttpError {
+    constructor(message = "Unauthorized") {
+        super(message, 401);
+        this.name = "UnauthorizedError";
+    }
+}

package/dist/src/errors/VoidString.error.d.ts

@@ -0,0 +1,4 @@
+import { HttpError } from "./HttpError";
+export declare class VoidString extends HttpError {
+    constructor(message?: string);
+}

package/dist/src/errors/VoidString.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class VoidString extends HttpError {
+    constructor(message = "Void String is invalid") {
+        super(message, 409);
+        this.name = "VoidString";
+    }
+}

package/dist/src/errors/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./HttpError";
+export * from "./Unauthorized.error";
+export * from "./NotFound.error";
+export * from "./BadRequest.error";
+export * from "./Conflict.error";

package/dist/src/errors/index.js

@@ -0,0 +1,5 @@
+export * from "./HttpError";
+export * from "./Unauthorized.error";
+export * from "./NotFound.error";
+export * from "./BadRequest.error";
+export * from "./Conflict.error";

package/dist/src/guards/BackOffice.guard.d.ts

@@ -0,0 +1,7 @@
+export declare const AuthorizationHeadersDto: import("@sinclair/typebox").TObject<{
+    authorization: import("@sinclair/typebox").TString;
+}>;
+export type AuthorizationHeaders = typeof AuthorizationHeadersDto.static;
+export declare function BackOfficeGuard({ headers }: {
+    headers: AuthorizationHeaders;
+}): Promise<void>;

package/dist/src/guards/BackOffice.guard.js

@@ -0,0 +1,10 @@
+import { UnauthorizedError } from "@/errors";
+import { t } from "elysia";
+export const AuthorizationHeadersDto = t.Object({
+    authorization: t.String(),
+});
+export async function BackOfficeGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.BACKOFFICE_SECRET}`) {
+        throw new UnauthorizedError();
+    }
+}

package/dist/src/guards/Engine.guard.d.ts

@@ -0,0 +1,7 @@
+export declare const AuthorizationHeadersDto: import("@sinclair/typebox").TObject<{
+    authorization: import("@sinclair/typebox").TString;
+}>;
+export type AuthorizationHeaders = typeof AuthorizationHeadersDto.static;
+export declare function EngineGuard({ headers }: {
+    headers: AuthorizationHeaders;
+}): Promise<void>;

package/dist/src/guards/Engine.guard.js

@@ -0,0 +1,10 @@
+import { UnauthorizedError } from "@/errors";
+import { t } from "elysia";
+export const AuthorizationHeadersDto = t.Object({
+    authorization: t.String(),
+});
+export async function EngineGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.ENGINE_SECRET}`) {
+        throw new UnauthorizedError();
+    }
+}

package/dist/src/guards/TokenAuth.guard.d.ts

@@ -0,0 +1,7 @@
+export declare const AuthorizationHeadersDto: import("@sinclair/typebox").TObject<{
+    authorization: import("@sinclair/typebox").TString;
+}>;
+export type AuthorizationHeaders = typeof AuthorizationHeadersDto.static;
+export declare function TokenAuthGuard({ headers }: {
+    headers: AuthorizationHeaders;
+}): Promise<void>;

package/dist/src/guards/TokenAuth.guard.js

@@ -0,0 +1,10 @@
+import { UnauthorizedError } from "@/errors";
+import { t } from "elysia";
+export const AuthorizationHeadersDto = t.Object({
+    authorization: t.String(),
+});
+export async function TokenAuthGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.API_SECRET}`) {
+        throw new UnauthorizedError();
+    }
+}

package/dist/src/hooks/checkQueryAddressValidity.d.ts

@@ -0,0 +1,22 @@
+import type Elysia from "elysia";
+export default function checkQueryAddressValidity(queryKey?: string): (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/hooks/checkQueryAddressValidity.js

@@ -0,0 +1,7 @@
+import { throwOnInvalidAddress } from "../utils/throw";
+export default function checkQueryAddressValidity(queryKey = "user") {
+    return (app) => app.onBeforeHandle(({ query }) => {
+        const address = query?.[queryKey];
+        query[queryKey] = throwOnInvalidAddress(address ?? "");
+    });
+}

package/dist/src/hooks/checkQueryChainIdValidity.d.ts

@@ -0,0 +1,22 @@
+import type Elysia from "elysia";
+export default function checkQueryChainIdValidity(queryKey?: string): (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/hooks/checkQueryChainIdValidity.js

@@ -0,0 +1,7 @@
+import { throwOnUnsupportedChainId } from "../utils/throw";
+export default function checkQueryChainIdValidity(queryKey = "chainId") {
+    return (app) => app.onBeforeHandle(({ query }) => {
+        const chainId = query?.[queryKey];
+        chainId !== undefined && throwOnUnsupportedChainId(chainId);
+    });
+}