@merkl/api 0.10.78

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

@@ -0,0 +1,4882 @@
+import type { Campaign as CampaignResource } from "../modules/v4";
+import type { CampaignType } from "../../database/api/.generated";
+declare const eden: {
+    valueOf: {};
+    index: {
+        get: (options?: {
+            headers?: Record<string, unknown> | undefined;
+            query?: Record<string, unknown> | undefined;
+            fetch?: RequestInit | undefined;
+        } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+            200: string;
+        }>>;
+    };
+    v4: {
+        opportunities: ((params: {
+            id: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: {
+                    aprRecord: {
+                        cumulated: number;
+                        cummulated: number;
+                        timestamp: bigint;
+                        breakdowns: {
+                            id: number;
+                            identifier: string;
+                            type: import("../../database/api/.generated").$Enums.AprType;
+                            value: number;
+                            aprRecordId: string;
+                        }[];
+                    };
+                    tvlRecord: {
+                        id: string;
+                        total: number;
+                        timestamp: bigint;
+                        breakdowns: {
+                            id: number;
+                            identifier: string;
+                            type: import("../../database/api/.generated").$Enums.TvlType;
+                            value: number;
+                            tvlRecordId: string;
+                        }[];
+                    };
+                    rewardsRecord: {
+                        id: string;
+                        total: number;
+                        timestamp: bigint;
+                        breakdowns: {
+                            id: number;
+                            value: number;
+                            campaignId: string;
+                            dailyRewardsRecordId: string;
+                        }[];
+                    };
+                    id: string;
+                    tokens: {
+                        id: string;
+                        name: string | null;
+                        chainId: number;
+                        address: string;
+                        decimals: number;
+                        symbol: string;
+                        icon: string;
+                        verified: boolean;
+                        price: number | null;
+                    }[];
+                    chain: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    };
+                    protocol: {
+                        id: string;
+                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    } | undefined;
+                    name: string;
+                    type: import("../../database/api/.generated").$Enums.CampaignType;
+                    status: import("../../database/api/.generated").$Enums.Status;
+                    tags: string[];
+                    identifier: string;
+                    chainId: number;
+                    action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                    tvl: number;
+                    apr: number;
+                    dailyRewards: number;
+                } | null | undefined;
+            }>>;
+            campaigns: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        aprRecord: {
+                            cumulated: number;
+                            cummulated: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                identifier: string;
+                                type: import("../../database/api/.generated").$Enums.AprType;
+                                value: number;
+                                aprRecordId: string;
+                            }[];
+                        };
+                        tvlRecord: {
+                            id: string;
+                            total: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                identifier: string;
+                                type: import("../../database/api/.generated").$Enums.TvlType;
+                                value: number;
+                                tvlRecordId: string;
+                            }[];
+                        };
+                        rewardsRecord: {
+                            id: string;
+                            total: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                value: number;
+                                campaignId: string;
+                                dailyRewardsRecordId: string;
+                            }[];
+                        };
+                        id: string;
+                        tokens: {
+                            id: string;
+                            name: string | null;
+                            chainId: number;
+                            address: string;
+                            decimals: number;
+                            symbol: string;
+                            icon: string;
+                            verified: boolean;
+                            price: number | null;
+                        }[];
+                        chain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        };
+                        protocol: {
+                            id: string;
+                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                            name: string;
+                            description: string;
+                            url: string;
+                            icon: string;
+                        } | undefined;
+                        name: string;
+                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                        status: import("../../database/api/.generated").$Enums.Status;
+                        tags: string[];
+                        identifier: string;
+                        chainId: number;
+                        action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                        tvl: number;
+                        apr: number;
+                        dailyRewards: number;
+                    } | null | undefined;
+                }>>;
+            };
+        }) & {
+            index: {
+                post: (body: {
+                    name?: string | undefined;
+                    type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4";
+                    tokens: {
+                        chainId: number;
+                        address: string;
+                    }[];
+                    status: "NONE" | "PAST" | "LIVE" | "SOON";
+                    identifier: string;
+                    chainId: number;
+                    action: "INVALID" | "POOL" | "HOLD" | "DROP" | "LEND" | "BORROW";
+                    protocols: string[];
+                    mainProtocol: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        sort?: "tvl" | "apr" | "rewards" | undefined;
+                        name?: string | undefined;
+                        tokens?: string | undefined;
+                        status?: string | undefined;
+                        items?: number | undefined;
+                        tags?: string | undefined;
+                        chainId?: string | undefined;
+                        page?: number | undefined;
+                        action?: string | undefined;
+                        mainProtocolId?: string | undefined;
+                        order?: "asc" | "desc" | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        aprRecord: {
+                            cumulated: number;
+                            cummulated: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                identifier: string;
+                                type: import("../../database/api/.generated").$Enums.AprType;
+                                value: number;
+                                aprRecordId: string;
+                            }[];
+                        };
+                        tvlRecord: {
+                            id: string;
+                            total: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                identifier: string;
+                                type: import("../../database/api/.generated").$Enums.TvlType;
+                                value: number;
+                                tvlRecordId: string;
+                            }[];
+                        };
+                        rewardsRecord: {
+                            id: string;
+                            total: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                value: number;
+                                campaignId: string;
+                                dailyRewardsRecordId: string;
+                            }[];
+                        };
+                        id: string;
+                        tokens: {
+                            id: string;
+                            name: string | null;
+                            chainId: number;
+                            address: string;
+                            decimals: number;
+                            symbol: string;
+                            icon: string;
+                            verified: boolean;
+                            price: number | null;
+                        }[];
+                        chain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        };
+                        protocol: {
+                            id: string;
+                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                            name: string;
+                            description: string;
+                            url: string;
+                            icon: string;
+                        } | undefined;
+                        name: string;
+                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                        status: import("../../database/api/.generated").$Enums.Status;
+                        tags: string[];
+                        identifier: string;
+                        chainId: number;
+                        action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                        tvl: number;
+                        apr: number;
+                        dailyRewards: number;
+                    } | null)[];
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        sort?: "tvl" | "apr" | "rewards" | undefined;
+                        name?: string | undefined;
+                        tokens?: string | undefined;
+                        status?: string | undefined;
+                        items?: number | undefined;
+                        tags?: string | undefined;
+                        chainId?: string | undefined;
+                        page?: number | undefined;
+                        action?: string | undefined;
+                        mainProtocolId?: string | undefined;
+                        order?: "asc" | "desc" | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        campaigns: {
+            index: {
+                post: (body: {
+                    subType?: number | undefined;
+                    type: number;
+                    params: string;
+                    identifier: string;
+                    chainId: number;
+                    startTimestamp: string;
+                    endTimestamp: string;
+                    computeChainId: number;
+                    campaignId: string;
+                    amount: string;
+                    creator: string;
+                    rewardTokenAddress: string;
+                    opportunityIdentifier: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: unknown;
+                }>>;
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
+                        items?: number | undefined;
+                        identifier?: string | undefined;
+                        subType?: number | undefined;
+                        chainId?: number | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        page?: number | undefined;
+                        mainParameter?: string | undefined;
+                        campaignId?: string | undefined;
+                        opportunityId?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        params: any;
+                        chain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        };
+                        rewardToken: {
+                            id: string;
+                            name: string | null;
+                            chainId: number;
+                            address: string;
+                            decimals: number;
+                            symbol: string;
+                            icon: string;
+                            verified: boolean;
+                            price: number | null;
+                        };
+                        distributionChain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        } | undefined;
+                        id: string;
+                        computeChainId: number;
+                        distributionChainId: number;
+                        identifier: string;
+                        campaignId: string;
+                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                        subType: number | null;
+                        rewardTokenId: string;
+                        amount: string;
+                        opportunityId: string;
+                        startTimestamp: bigint;
+                        endTimestamp: bigint;
+                        creatorAddress: string;
+                    } | null)[];
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
+                        items?: number | undefined;
+                        identifier?: string | undefined;
+                        subType?: number | undefined;
+                        chainId?: number | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        page?: number | undefined;
+                        mainParameter?: string | undefined;
+                        campaignId?: string | undefined;
+                        opportunityId?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        protocols: ((params: {
+            id: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: ({
+                    name: string;
+                    url: string;
+                    description: string;
+                    tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                    icon: string;
+                } & {}) | null;
+            }>>;
+        }) & {
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        name?: string | undefined;
+                        id?: string[] | undefined;
+                        items?: number | undefined;
+                        tags?: ("AMM" | "ALM" | "DEX" | "LENDING")[] | undefined;
+                        page?: number | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        name: string;
+                        url: string;
+                        description: string;
+                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                        icon: string;
+                    } & {})[] | null;
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        name?: string | undefined;
+                        id?: string[] | undefined;
+                        items?: number | undefined;
+                        tags?: ("AMM" | "ALM" | "DEX" | "LENDING")[] | undefined;
+                        page?: number | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        tokens: ((params: {
+            id: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: ({
+                    symbol: string;
+                    name: string | null;
+                    id: string;
+                    chainId: number;
+                    address: string;
+                    icon: string;
+                    decimals: number;
+                    verified: boolean;
+                } & {
+                    price?: number | null | undefined;
+                }) | undefined;
+            }>>;
+        }) & {
+            balances: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        tokenAddress?: string | undefined;
+                        additionalTokenAddresses?: string[] | undefined;
+                        chainId: number;
+                        userAddress: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        symbol: string;
+                        name: string | null;
+                        id: string;
+                        chainId: number;
+                        address: string;
+                        icon: string;
+                        decimals: number;
+                        verified: boolean;
+                    } & {
+                        price?: number | null | undefined;
+                    } & {
+                        balance: bigint;
+                    })[];
+                }>>;
+            };
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        symbol?: string | undefined;
+                        name?: string | undefined;
+                        chainId?: any;
+                        address?: string | undefined;
+                        verified?: boolean | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        symbol: string;
+                        name: string | null;
+                        id: string;
+                        chainId: number;
+                        address: string;
+                        icon: string;
+                        decimals: number;
+                        verified: boolean;
+                    } & {
+                        price?: number | null | undefined;
+                    })[];
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        symbol?: string | undefined;
+                        name?: string | undefined;
+                        chainId?: any;
+                        address?: string | undefined;
+                        verified?: boolean | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        rewards: {
+            engine: {
+                post: (body: {
+                    recipient: string;
+                    distributionChainId: number;
+                    root: string;
+                    proofs: string[];
+                    rewardToken: string;
+                }[], options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: import("../../database/api/.generated").Prisma.BatchPayload;
+                }>>;
+                breakdowns: {
+                    post: (body: {
+                        distributionChainId: number;
+                        campaignId: string;
+                        root: string;
+                        rewardToken: string;
+                        breakdowns: {
+                            protocolId?: string | undefined;
+                            auxiliaryData1?: string | undefined;
+                            auxiliaryData2?: string | undefined;
+                            reason: string;
+                            pending: string;
+                            recipient: string;
+                            amount: string;
+                            claimed: string;
+                        }[];
+                    }[], options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: import("../../database/api/.generated").Prisma.BatchPayload;
+                    }>>;
+                };
+            };
+            pendings: {
+                post: (body: {
+                    distributionChainId: number;
+                    campaignId: string;
+                    root: string;
+                    rewardToken: string;
+                    toUpdate: {
+                        auxiliaryData1?: string | undefined;
+                        auxiliaryData2?: string | undefined;
+                        reason: string;
+                        pending: string;
+                        recipient: string;
+                    }[];
+                    toCreate: {
+                        auxiliaryData1?: string | undefined;
+                        auxiliaryData2?: string | undefined;
+                        reason: string;
+                        pending: string;
+                        recipient: string;
+                    }[];
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: Record<string, {
+                        breakdown: number;
+                        rewards: Record<string, number>;
+                    }>;
+                }>>;
+            };
+            breakdown: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        items?: number | undefined;
+                        page?: number | undefined;
+                        chainId: number;
+                        campaignIdentifiers: string | string[];
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        Campaign: {
+                            identifier: string;
+                            campaignId: string;
+                        };
+                        amount: string;
+                        Reward: {
+                            recipient: string;
+                        };
+                    }[];
+                }>>;
+            };
+        };
+        chains: ((params: {
+            chainId: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: ({
+                    Explorer: {
+                        id: string;
+                        type: import("../../database/api/.generated").$Enums.ExplorerType;
+                        url: string;
+                        chainId: number;
+                    }[];
+                } & {
+                    id: number;
+                    name: string;
+                    icon: string;
+                }) | null;
+            }>>;
+        }) & {
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        search?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        Explorer: {
+                            id: string;
+                            type: import("../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            chainId: number;
+                        }[];
+                    } & {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    })[];
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        search?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        prices: {
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        [token: string]: number;
+                    };
+                }>>;
+            };
+            symbol: ((params: {
+                symbol: string | number;
+            }) => {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            }) & {};
+            sources: {
+                index: {
+                    get: (options?: {
+                        headers?: Record<string, unknown> | undefined;
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            id: number;
+                            symbol: string;
+                            method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                            args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                        }[];
+                    }>>;
+                    post: (body: {
+                        symbol: string;
+                        method: "COINGECKO" | "CONSTANT" | "EQUAL_TO" | "ERC4626" | "DEXSCREENER" | "INDEXCOOP" | "DEFILLAMA";
+                        args: {};
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: number | undefined;
+                    }>>;
+                };
+                symbol: ((params: {
+                    symbol: string | number;
+                }) => {
+                    get: (options?: {
+                        headers?: Record<string, unknown> | undefined;
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            id: number;
+                            symbol: string;
+                            method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                            args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                        };
+                    }>>;
+                    patch: (body: {
+                        symbol?: string | undefined;
+                        method?: "COINGECKO" | "CONSTANT" | "EQUAL_TO" | "ERC4626" | "DEXSCREENER" | "INDEXCOOP" | "DEFILLAMA" | undefined;
+                        args?: {} | undefined;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            id: number;
+                            symbol: string;
+                            method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                            args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                        };
+                    }>>;
+                    delete: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            id: number;
+                            symbol: string;
+                            method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                            args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                        };
+                    }>>;
+                }) & {};
+            };
+        };
+        blacklists: {
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        id: string;
+                        chainId: number;
+                        poolAddress: string;
+                        userAddress: string;
+                        arrestTimestamp: bigint;
+                        arrestDetails: import("../../database/api/.generated").Prisma.JsonValue;
+                    }[];
+                }>>;
+                post: (body: {
+                    reason?: string | undefined;
+                    chainId: number;
+                    poolAddress: string;
+                    userAddress: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        id: string;
+                        chainId: number;
+                        poolAddress: string;
+                        userAddress: string;
+                        arrestTimestamp: bigint;
+                        arrestDetails: import("../../database/api/.generated").Prisma.JsonValue;
+                    };
+                }>>;
+            };
+            all: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: string[];
+                }>>;
+            };
+            check: ((params: {
+                address: string | number;
+            }) => {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            }) & {};
+            user: ((params: {
+                address: string | number;
+            }) => {
+                delete: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            }) & {};
+        };
+        users: ((params: {
+            address: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: {
+                    address: string;
+                } | null;
+            }>>;
+            rewards: {
+                full: {
+                    get: (options?: {
+                        headers?: Record<string, unknown> | undefined;
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: (Omit<{
+                            chain: import("../../database/api/.generated").Chain;
+                            rewards: Awaited<ReturnType<typeof import("../modules/v4/reward").RewardService["getByRecipient"]>>;
+                        }, "rewards"> & {
+                            rewards: (Omit<{
+                                token: {
+                                    id: string;
+                                    name: string | null;
+                                    chainId: number;
+                                    address: string;
+                                    decimals: number;
+                                    symbol: string;
+                                    icon: string;
+                                    verified: boolean;
+                                    price: number | null;
+                                };
+                                breakdowns: {
+                                    campaignId: string;
+                                    opportunity: {
+                                        Chain: {
+                                            id: number;
+                                            name: string;
+                                            icon: string;
+                                        };
+                                        Tokens: {
+                                            id: string;
+                                            name: string | null;
+                                            chainId: number;
+                                            address: string;
+                                            decimals: number;
+                                            symbol: string;
+                                            icon: string;
+                                            verified: boolean;
+                                            price: number | null;
+                                        }[];
+                                        Protocols: {
+                                            id: string;
+                                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                            name: string;
+                                            description: string;
+                                            url: string;
+                                            icon: string;
+                                        }[];
+                                        MainProtocol: {
+                                            id: string;
+                                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                            name: string;
+                                            description: string;
+                                            url: string;
+                                            icon: string;
+                                        } | null;
+                                    } & {
+                                        id: string;
+                                        chainId: number;
+                                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                                        identifier: string;
+                                        name: string;
+                                        status: import("../../database/api/.generated").$Enums.Status;
+                                        action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                                        mainProtocolId: string | null;
+                                        tvl: number;
+                                        apr: number;
+                                        dailyRewards: number;
+                                        tags: string[];
+                                    };
+                                    reason: string;
+                                    amount: string;
+                                    claimed: string;
+                                    pending: string;
+                                    auxiliaryData1: string | null;
+                                    auxiliaryData2: string | null;
+                                }[];
+                                claimed: bigint;
+                                amount: bigint;
+                                pending: bigint;
+                                root: string;
+                                recipient: string;
+                                proofs: string[];
+                            }, "breakdowns"> & {
+                                breakdowns: {
+                                    opportunity: import("../modules/v4").Opportunity["model"] | null;
+                                    claimed: bigint;
+                                    amount: bigint;
+                                    pending: bigint;
+                                    auxiliaryData1: string | null;
+                                    auxiliaryData2: string | null;
+                                }[];
+                            })[];
+                            distributor: string;
+                        })[];
+                    }>>;
+                };
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        chainId: number | number[];
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: (Omit<{
+                        chain: import("../../database/api/.generated").Chain;
+                        rewards: Awaited<ReturnType<typeof import("../modules/v4/reward").RewardService["getByRecipient"]>>;
+                    }, "rewards"> & {
+                        rewards: (Omit<{
+                            token: {
+                                id: string;
+                                name: string | null;
+                                chainId: number;
+                                address: string;
+                                decimals: number;
+                                symbol: string;
+                                icon: string;
+                                verified: boolean;
+                                price: number | null;
+                            };
+                            breakdowns: {
+                                campaignId: string;
+                                opportunity: {
+                                    Chain: {
+                                        id: number;
+                                        name: string;
+                                        icon: string;
+                                    };
+                                    Tokens: {
+                                        id: string;
+                                        name: string | null;
+                                        chainId: number;
+                                        address: string;
+                                        decimals: number;
+                                        symbol: string;
+                                        icon: string;
+                                        verified: boolean;
+                                        price: number | null;
+                                    }[];
+                                    Protocols: {
+                                        id: string;
+                                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                        name: string;
+                                        description: string;
+                                        url: string;
+                                        icon: string;
+                                    }[];
+                                    MainProtocol: {
+                                        id: string;
+                                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                        name: string;
+                                        description: string;
+                                        url: string;
+                                        icon: string;
+                                    } | null;
+                                } & {
+                                    id: string;
+                                    chainId: number;
+                                    type: import("../../database/api/.generated").$Enums.CampaignType;
+                                    identifier: string;
+                                    name: string;
+                                    status: import("../../database/api/.generated").$Enums.Status;
+                                    action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                                    mainProtocolId: string | null;
+                                    tvl: number;
+                                    apr: number;
+                                    dailyRewards: number;
+                                    tags: string[];
+                                };
+                                reason: string;
+                                amount: string;
+                                claimed: string;
+                                pending: string;
+                                auxiliaryData1: string | null;
+                                auxiliaryData2: string | null;
+                            }[];
+                            claimed: bigint;
+                            amount: bigint;
+                            pending: bigint;
+                            root: string;
+                            recipient: string;
+                            proofs: string[];
+                        }, "breakdowns"> & {
+                            breakdowns: {
+                                campaignId: string;
+                                reason: string;
+                                amount: string;
+                                claimed: string;
+                                pending: string;
+                                auxiliaryData1: string | null;
+                                auxiliaryData2: string | null;
+                            }[];
+                        })[];
+                    })[];
+                }>>;
+            };
+            tags: {
+                patch: (body: {
+                    tags: string[];
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        address: string;
+                        tags: string[];
+                    };
+                }>>;
+            };
+        }) & {
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        items?: number | undefined;
+                        tags?: string[] | undefined;
+                        page?: number | undefined;
+                        address?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        address: string;
+                        tags: string[];
+                    }[];
+                }>>;
+                post: (body: {
+                    tags: string[];
+                    address: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        address: string;
+                        tags: string[];
+                    };
+                }>>;
+            };
+        };
+        roots: {
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        chainId: number;
+                        fromTimestamp: string;
+                        toTimestamp: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        root: string;
+                        chainId: number;
+                        epoch: number;
+                        timestamp: bigint;
+                    }[];
+                }>>;
+            };
+        };
+        participate: {
+            targets: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        identifier?: string | undefined;
+                        chainId: number;
+                        protocolId: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: import("../modules/v4/participate/participate.model").ParticipateTarget[] | undefined;
+                }>>;
+            };
+            protocols: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        chainId?: number | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        name: string;
+                        url: string;
+                        description: string;
+                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                        icon: string;
+                    } & {})[] | null;
+                }>>;
+            };
+            quote: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        identifier: string;
+                        chainId: number;
+                        protocolId: string;
+                        userAddress: string;
+                        fromAmount: string;
+                        fromTokenAddress: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        amountOut: {};
+                        gas: string;
+                        feeAmount: string[];
+                        priceImpact: number;
+                    } | undefined;
+                }>>;
+            };
+            transaction: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        identifier: string;
+                        chainId: number;
+                        protocolId: string;
+                        userAddress: string;
+                        fromAmount: string;
+                        fromTokenAddress: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        amountOut: string;
+                        gas: string;
+                        feeAmount: string[];
+                        priceImpact: number;
+                        createAt: number;
+                        tx: {
+                            data: string;
+                            from: string;
+                            value: string;
+                            to: string;
+                        };
+                    } | undefined;
+                }>>;
+            };
+        };
+        accounting: {
+            index: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query: {
+                        items?: number | undefined;
+                        page?: number | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        id: string;
+                        chainId: number;
+                        fromTokenId: string;
+                        toTokenId: string;
+                        multisig: string;
+                        recipient: string;
+                        amountIn: string;
+                        amountOut: string;
+                        datetime: Date;
+                        timestamp: number;
+                    }[];
+                }>>;
+            };
+            revenues: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        totalAmount: number;
+                    };
+                }>>;
+                "per-month": ((params: {
+                    year: string | number;
+                }) => {} & ((params: {
+                    month: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            totalAmount: number;
+                            from: string;
+                            to: string;
+                        };
+                    }>>;
+                })) & {};
+                chains: ((params: {
+                    chainId: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            totalAmount: number;
+                        };
+                    }>>;
+                    "per-month": ((params: {
+                        year: string | number;
+                    }) => {} & ((params: {
+                        month: string | number;
+                    }) => {
+                        get: (options: {
+                            headers: {
+                                authorization: string;
+                            };
+                            query?: Record<string, unknown> | undefined;
+                            fetch?: RequestInit | undefined;
+                        }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                            200: {
+                                totalAmount: number;
+                                from: string;
+                                to: string;
+                            };
+                        }>>;
+                    })) & {};
+                }) & {};
+            };
+            tokens: ((params: {
+                chainId: string | number;
+            }) => {} & ((params: {
+                tokenAddress: string | number;
+            }) => {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        totalAmount: number;
+                        totalAmountUSD: number;
+                    };
+                }>>;
+                "per-month": ((params: {
+                    year: string | number;
+                }) => {} & ((params: {
+                    month: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            totalAmount: number;
+                            totalAmountUSD: number;
+                            from: string;
+                            to: string;
+                        };
+                    }>>;
+                })) & {};
+            })) & {};
+        };
+        campaignStatus: {
+            engine: {
+                post: (body: {
+                    status: {
+                        value: "SUCCESS";
+                        computedUntil: number;
+                    } | {
+                        value: "PROCESSING";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "SKIPPED";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "FAILED";
+                    };
+                    campaignId: string;
+                    distributionChain: number;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    }[];
+                }>>;
+            };
+            unique: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        identifier: string;
+                        distributionChain: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    };
+                }>>;
+            };
+            computeChain: ((params: {
+                chainId: string | number;
+            }) => {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    }[];
+                }>>;
+            }) & {};
+            overlaps: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query: {
+                        identifier: string;
+                        distributionChain: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            };
+        };
+    };
+};
+type Api = typeof eden;
+type ApiModuleVersion = Exclude<keyof Api, "index" | "valueOf">;
+type ApiModuleRoute<V extends ApiModuleVersion> = keyof Api[V];
+export type OneOfRoute<R extends ApiModuleRoute<"v4">> = NonNullable<RouteType<"v4", R>["data"]>[number];
+export type FromPromise<R extends (...args: any) => Promise<{
+    data: any;
+}>> = NonNullable<NonNullable<Awaited<ReturnType<R>>["data"]>[number]>;
+type RouteType<V extends ApiModuleVersion, R extends ApiModuleRoute<V>> = Awaited<ReturnType<"get" extends keyof Api[V][R] ? (Api[V][R]["get"] extends (...args: any) => any ? Api[V][R]["get"] : never) : never>>;
+export declare const MerklApi: (domain: string | import("elysia").default<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {
+        readonly HttpError: import("../errors").HttpError;
+        readonly BadRequestError: import("../errors").BadRequestError;
+        readonly ConflictError: import("../errors").ConflictError;
+        readonly NotFoundError: import("../errors").NotFoundError;
+        readonly UnauthorizedError: import("../errors").UnauthorizedError;
+        readonly InvalidParameter: import("../utils/error").InvalidParameter;
+        readonly UnsupportedNetwork: import("../utils/error").UnsupportedNetwork;
+        readonly OpportunityNotFound: import("../utils/error").OpportunityNotFound;
+        readonly MerkleRootNotFound: import("../utils/error").MerkleRootNotFound;
+        readonly ValidationError: import("elysia").ValidationError;
+        readonly InvalidCacheCall: import("../utils/error").InvalidCacheCall;
+    };
+}, {
+    schema: {};
+    macro: {};
+}, false & {
+    index: {
+        get: {
+            body: unknown;
+            params: Record<never, string>;
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: string;
+            };
+        };
+    };
+} & {
+    v4: {};
+} & {
+    v4: {
+        opportunities: {
+            index: {
+                post: {
+                    body: {
+                        name?: string | undefined;
+                        type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4";
+                        tokens: {
+                            chainId: number;
+                            address: string;
+                        }[];
+                        status: "NONE" | "PAST" | "LIVE" | "SOON";
+                        identifier: string;
+                        chainId: number;
+                        action: "INVALID" | "POOL" | "HOLD" | "DROP" | "LEND" | "BORROW";
+                        protocols: string[];
+                        mainProtocol: string;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        opportunities: {
+            ":id": {
+                get: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            aprRecord: {
+                                cumulated: number;
+                                cummulated: number;
+                                timestamp: bigint;
+                                breakdowns: {
+                                    id: number;
+                                    identifier: string;
+                                    type: import("../../database/api/.generated").$Enums.AprType;
+                                    value: number;
+                                    aprRecordId: string;
+                                }[];
+                            };
+                            tvlRecord: {
+                                id: string;
+                                total: number;
+                                timestamp: bigint;
+                                breakdowns: {
+                                    id: number;
+                                    identifier: string;
+                                    type: import("../../database/api/.generated").$Enums.TvlType;
+                                    value: number;
+                                    tvlRecordId: string;
+                                }[];
+                            };
+                            rewardsRecord: {
+                                id: string;
+                                total: number;
+                                timestamp: bigint;
+                                breakdowns: {
+                                    id: number;
+                                    value: number;
+                                    campaignId: string;
+                                    dailyRewardsRecordId: string;
+                                }[];
+                            };
+                            id: string;
+                            tokens: {
+                                id: string;
+                                name: string | null;
+                                chainId: number;
+                                address: string;
+                                decimals: number;
+                                symbol: string;
+                                icon: string;
+                                verified: boolean;
+                                price: number | null;
+                            }[];
+                            chain: {
+                                id: number;
+                                name: string;
+                                icon: string;
+                            };
+                            protocol: {
+                                id: string;
+                                tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                name: string;
+                                description: string;
+                                url: string;
+                                icon: string;
+                            } | undefined;
+                            name: string;
+                            type: import("../../database/api/.generated").$Enums.CampaignType;
+                            status: import("../../database/api/.generated").$Enums.Status;
+                            tags: string[];
+                            identifier: string;
+                            chainId: number;
+                            action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                            tvl: number;
+                            apr: number;
+                            dailyRewards: number;
+                        } | null | undefined;
+                    };
+                };
+            };
+        };
+    } & {
+        opportunities: {
+            ":id": {
+                campaigns: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            id: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                aprRecord: {
+                                    cumulated: number;
+                                    cummulated: number;
+                                    timestamp: bigint;
+                                    breakdowns: {
+                                        id: number;
+                                        identifier: string;
+                                        type: import("../../database/api/.generated").$Enums.AprType;
+                                        value: number;
+                                        aprRecordId: string;
+                                    }[];
+                                };
+                                tvlRecord: {
+                                    id: string;
+                                    total: number;
+                                    timestamp: bigint;
+                                    breakdowns: {
+                                        id: number;
+                                        identifier: string;
+                                        type: import("../../database/api/.generated").$Enums.TvlType;
+                                        value: number;
+                                        tvlRecordId: string;
+                                    }[];
+                                };
+                                rewardsRecord: {
+                                    id: string;
+                                    total: number;
+                                    timestamp: bigint;
+                                    breakdowns: {
+                                        id: number;
+                                        value: number;
+                                        campaignId: string;
+                                        dailyRewardsRecordId: string;
+                                    }[];
+                                };
+                                id: string;
+                                tokens: {
+                                    id: string;
+                                    name: string | null;
+                                    chainId: number;
+                                    address: string;
+                                    decimals: number;
+                                    symbol: string;
+                                    icon: string;
+                                    verified: boolean;
+                                    price: number | null;
+                                }[];
+                                chain: {
+                                    id: number;
+                                    name: string;
+                                    icon: string;
+                                };
+                                protocol: {
+                                    id: string;
+                                    tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                    name: string;
+                                    description: string;
+                                    url: string;
+                                    icon: string;
+                                } | undefined;
+                                name: string;
+                                type: import("../../database/api/.generated").$Enums.CampaignType;
+                                status: import("../../database/api/.generated").$Enums.Status;
+                                tags: string[];
+                                identifier: string;
+                                chainId: number;
+                                action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                                tvl: number;
+                                apr: number;
+                                dailyRewards: number;
+                            } | null | undefined;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        opportunities: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        sort?: "tvl" | "apr" | "rewards" | undefined;
+                        name?: string | undefined;
+                        tokens?: string | undefined;
+                        status?: string | undefined;
+                        items?: number | undefined;
+                        tags?: string | undefined;
+                        chainId?: string | undefined;
+                        page?: number | undefined;
+                        action?: string | undefined;
+                        mainProtocolId?: string | undefined;
+                        order?: "asc" | "desc" | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            aprRecord: {
+                                cumulated: number;
+                                cummulated: number;
+                                timestamp: bigint;
+                                breakdowns: {
+                                    id: number;
+                                    identifier: string;
+                                    type: import("../../database/api/.generated").$Enums.AprType;
+                                    value: number;
+                                    aprRecordId: string;
+                                }[];
+                            };
+                            tvlRecord: {
+                                id: string;
+                                total: number;
+                                timestamp: bigint;
+                                breakdowns: {
+                                    id: number;
+                                    identifier: string;
+                                    type: import("../../database/api/.generated").$Enums.TvlType;
+                                    value: number;
+                                    tvlRecordId: string;
+                                }[];
+                            };
+                            rewardsRecord: {
+                                id: string;
+                                total: number;
+                                timestamp: bigint;
+                                breakdowns: {
+                                    id: number;
+                                    value: number;
+                                    campaignId: string;
+                                    dailyRewardsRecordId: string;
+                                }[];
+                            };
+                            id: string;
+                            tokens: {
+                                id: string;
+                                name: string | null;
+                                chainId: number;
+                                address: string;
+                                decimals: number;
+                                symbol: string;
+                                icon: string;
+                                verified: boolean;
+                                price: number | null;
+                            }[];
+                            chain: {
+                                id: number;
+                                name: string;
+                                icon: string;
+                            };
+                            protocol: {
+                                id: string;
+                                tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                name: string;
+                                description: string;
+                                url: string;
+                                icon: string;
+                            } | undefined;
+                            name: string;
+                            type: import("../../database/api/.generated").$Enums.CampaignType;
+                            status: import("../../database/api/.generated").$Enums.Status;
+                            tags: string[];
+                            identifier: string;
+                            chainId: number;
+                            action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                            tvl: number;
+                            apr: number;
+                            dailyRewards: number;
+                        } | null)[];
+                    };
+                };
+            };
+        };
+    } & {
+        opportunities: {
+            count: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        sort?: "tvl" | "apr" | "rewards" | undefined;
+                        name?: string | undefined;
+                        tokens?: string | undefined;
+                        status?: string | undefined;
+                        items?: number | undefined;
+                        tags?: string | undefined;
+                        chainId?: string | undefined;
+                        page?: number | undefined;
+                        action?: string | undefined;
+                        mainProtocolId?: string | undefined;
+                        order?: "asc" | "desc" | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: number;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        campaigns: {
+            index: {
+                post: {
+                    body: {
+                        subType?: number | undefined;
+                        type: number;
+                        params: string;
+                        identifier: string;
+                        chainId: number;
+                        startTimestamp: string;
+                        endTimestamp: string;
+                        computeChainId: number;
+                        campaignId: string;
+                        amount: string;
+                        creator: string;
+                        rewardTokenAddress: string;
+                        opportunityIdentifier: string;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: unknown;
+                    };
+                };
+            };
+        };
+    } & {
+        campaigns: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
+                        items?: number | undefined;
+                        identifier?: string | undefined;
+                        subType?: number | undefined;
+                        chainId?: number | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        page?: number | undefined;
+                        mainParameter?: string | undefined;
+                        campaignId?: string | undefined;
+                        opportunityId?: string | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            params: any;
+                            chain: {
+                                id: number;
+                                name: string;
+                                icon: string;
+                            };
+                            rewardToken: {
+                                id: string;
+                                name: string | null;
+                                chainId: number;
+                                address: string;
+                                decimals: number;
+                                symbol: string;
+                                icon: string;
+                                verified: boolean;
+                                price: number | null;
+                            };
+                            distributionChain: {
+                                id: number;
+                                name: string;
+                                icon: string;
+                            } | undefined;
+                            id: string;
+                            computeChainId: number;
+                            distributionChainId: number;
+                            identifier: string;
+                            campaignId: string;
+                            type: import("../../database/api/.generated").$Enums.CampaignType;
+                            subType: number | null;
+                            rewardTokenId: string;
+                            amount: string;
+                            opportunityId: string;
+                            startTimestamp: bigint;
+                            endTimestamp: bigint;
+                            creatorAddress: string;
+                        } | null)[];
+                    };
+                };
+            };
+        };
+    } & {
+        campaigns: {
+            count: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
+                        items?: number | undefined;
+                        identifier?: string | undefined;
+                        subType?: number | undefined;
+                        chainId?: number | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        page?: number | undefined;
+                        mainParameter?: string | undefined;
+                        campaignId?: string | undefined;
+                        opportunityId?: string | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: number;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        protocols: {
+            ":id": {
+                get: {
+                    body: unknown;
+                    params: Record<"id", string>;
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            name: string;
+                            url: string;
+                            description: string;
+                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                            icon: string;
+                        } & {}) | null;
+                    };
+                };
+            };
+        };
+    } & {
+        protocols: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        name?: string | undefined;
+                        id?: string[] | undefined;
+                        items?: number | undefined;
+                        tags?: ("AMM" | "ALM" | "DEX" | "LENDING")[] | undefined;
+                        page?: number | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            name: string;
+                            url: string;
+                            description: string;
+                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                            icon: string;
+                        } & {})[] | null;
+                    };
+                };
+            };
+        };
+    } & {
+        protocols: {
+            count: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        name?: string | undefined;
+                        id?: string[] | undefined;
+                        items?: number | undefined;
+                        tags?: ("AMM" | "ALM" | "DEX" | "LENDING")[] | undefined;
+                        page?: number | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: number;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        tokens: {
+            ":id": {
+                get: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            symbol: string;
+                            name: string | null;
+                            id: string;
+                            chainId: number;
+                            address: string;
+                            icon: string;
+                            decimals: number;
+                            verified: boolean;
+                        } & {
+                            price?: number | null | undefined;
+                        }) | undefined;
+                    };
+                };
+            };
+        };
+    } & {
+        tokens: {
+            balances: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        tokenAddress?: string | undefined;
+                        additionalTokenAddresses?: string[] | undefined;
+                        chainId: number;
+                        userAddress: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            symbol: string;
+                            name: string | null;
+                            id: string;
+                            chainId: number;
+                            address: string;
+                            icon: string;
+                            decimals: number;
+                            verified: boolean;
+                        } & {
+                            price?: number | null | undefined;
+                        } & {
+                            balance: bigint;
+                        })[];
+                    };
+                };
+            };
+        };
+    } & {
+        tokens: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        symbol?: string | undefined;
+                        name?: string | undefined;
+                        chainId?: any;
+                        address?: string | undefined;
+                        verified?: boolean | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            symbol: string;
+                            name: string | null;
+                            id: string;
+                            chainId: number;
+                            address: string;
+                            icon: string;
+                            decimals: number;
+                            verified: boolean;
+                        } & {
+                            price?: number | null | undefined;
+                        })[];
+                    };
+                };
+            };
+        };
+    } & {
+        tokens: {
+            count: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        symbol?: string | undefined;
+                        name?: string | undefined;
+                        chainId?: any;
+                        address?: string | undefined;
+                        verified?: boolean | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: number;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        rewards: {
+            engine: {
+                post: {
+                    body: {
+                        recipient: string;
+                        distributionChainId: number;
+                        root: string;
+                        proofs: string[];
+                        rewardToken: string;
+                    }[];
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: import("../../database/api/.generated").Prisma.BatchPayload;
+                    };
+                };
+            };
+        };
+    } & {
+        rewards: {
+            engine: {
+                breakdowns: {
+                    post: {
+                        body: {
+                            distributionChainId: number;
+                            campaignId: string;
+                            root: string;
+                            rewardToken: string;
+                            breakdowns: {
+                                protocolId?: string | undefined;
+                                auxiliaryData1?: string | undefined;
+                                auxiliaryData2?: string | undefined;
+                                reason: string;
+                                pending: string;
+                                recipient: string;
+                                amount: string;
+                                claimed: string;
+                            }[];
+                        }[];
+                        params: Record<never, string>;
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: import("../../database/api/.generated").Prisma.BatchPayload;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        rewards: {
+            pendings: {
+                post: {
+                    body: {
+                        distributionChainId: number;
+                        campaignId: string;
+                        root: string;
+                        rewardToken: string;
+                        toUpdate: {
+                            auxiliaryData1?: string | undefined;
+                            auxiliaryData2?: string | undefined;
+                            reason: string;
+                            pending: string;
+                            recipient: string;
+                        }[];
+                        toCreate: {
+                            auxiliaryData1?: string | undefined;
+                            auxiliaryData2?: string | undefined;
+                            reason: string;
+                            pending: string;
+                            recipient: string;
+                        }[];
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: boolean;
+                    };
+                };
+            };
+        };
+    } & {
+        rewards: {
+            count: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: Record<string, {
+                            breakdown: number;
+                            rewards: Record<string, number>;
+                        }>;
+                    };
+                };
+            };
+        };
+    } & {
+        rewards: {
+            breakdown: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        items?: number | undefined;
+                        page?: number | undefined;
+                        chainId: number;
+                        campaignIdentifiers: string | string[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            Campaign: {
+                                identifier: string;
+                                campaignId: string;
+                            };
+                            amount: string;
+                            Reward: {
+                                recipient: string;
+                            };
+                        }[];
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        chains: {
+            ":chainId": {
+                get: {
+                    body: unknown;
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Explorer: {
+                                id: string;
+                                type: import("../../database/api/.generated").$Enums.ExplorerType;
+                                url: string;
+                                chainId: number;
+                            }[];
+                        } & {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        }) | null;
+                    };
+                };
+            };
+        };
+    } & {
+        chains: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        search?: string | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Explorer: {
+                                id: string;
+                                type: import("../../database/api/.generated").$Enums.ExplorerType;
+                                url: string;
+                                chainId: number;
+                            }[];
+                        } & {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        })[];
+                    };
+                };
+            };
+        };
+    } & {
+        chains: {
+            count: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        search?: string | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: number;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        prices: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            [token: string]: number;
+                        };
+                    };
+                };
+            };
+        } & {
+            symbol: {
+                ":symbol": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            symbol: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: number;
+                        };
+                    };
+                };
+            };
+        } & {
+            sources: {
+                index: {
+                    get: {
+                        body: unknown;
+                        params: Record<never, string>;
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                id: number;
+                                symbol: string;
+                                method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                                args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                            }[];
+                        };
+                    };
+                };
+            };
+        } & {
+            sources: {
+                symbol: {
+                    ":symbol": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                symbol: string;
+                            };
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                200: {
+                                    id: number;
+                                    symbol: string;
+                                    method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                                    args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            sources: {
+                index: {
+                    post: {
+                        body: {
+                            symbol: string;
+                            method: "COINGECKO" | "CONSTANT" | "EQUAL_TO" | "ERC4626" | "DEXSCREENER" | "INDEXCOOP" | "DEFILLAMA";
+                            args: {};
+                        };
+                        params: Record<never, string>;
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: number | undefined;
+                        };
+                    };
+                };
+            };
+        } & {
+            sources: {
+                symbol: {
+                    ":symbol": {
+                        patch: {
+                            body: {
+                                symbol?: string | undefined;
+                                method?: "COINGECKO" | "CONSTANT" | "EQUAL_TO" | "ERC4626" | "DEXSCREENER" | "INDEXCOOP" | "DEFILLAMA" | undefined;
+                                args?: {} | undefined;
+                            };
+                            params: {
+                                symbol: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: {
+                                    id: number;
+                                    symbol: string;
+                                    method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                                    args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            sources: {
+                symbol: {
+                    ":symbol": {
+                        delete: {
+                            body: unknown;
+                            params: {
+                                symbol: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: {
+                                    id: number;
+                                    symbol: string;
+                                    method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                                    args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        blacklists: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            id: string;
+                            chainId: number;
+                            poolAddress: string;
+                            userAddress: string;
+                            arrestTimestamp: bigint;
+                            arrestDetails: import("../../database/api/.generated").Prisma.JsonValue;
+                        }[];
+                    };
+                };
+            };
+        };
+    } & {
+        blacklists: {
+            all: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: string[];
+                    };
+                };
+            };
+        };
+    } & {
+        blacklists: {
+            check: {
+                ":address": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            address: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: boolean;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        blacklists: {
+            index: {
+                post: {
+                    body: {
+                        reason?: string | undefined;
+                        chainId: number;
+                        poolAddress: string;
+                        userAddress: string;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            id: string;
+                            chainId: number;
+                            poolAddress: string;
+                            userAddress: string;
+                            arrestTimestamp: bigint;
+                            arrestDetails: import("../../database/api/.generated").Prisma.JsonValue;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        blacklists: {
+            user: {
+                ":address": {
+                    delete: {
+                        body: unknown;
+                        params: {
+                            address: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: boolean;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        users: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        items?: number | undefined;
+                        tags?: string[] | undefined;
+                        page?: number | undefined;
+                        address?: string | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            address: string;
+                            tags: string[];
+                        }[];
+                    };
+                };
+            };
+        };
+    } & {
+        users: {
+            ":address": {
+                get: {
+                    body: unknown;
+                    params: Record<"address", string>;
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            address: string;
+                        } | null;
+                    };
+                };
+            };
+        };
+    } & {
+        users: {
+            ":address": {
+                rewards: {
+                    full: {
+                        get: {
+                            body: unknown;
+                            params: {
+                                address: string;
+                            };
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                200: (Omit<{
+                                    chain: import("../../database/api/.generated").Chain;
+                                    rewards: Awaited<ReturnType<typeof import("../modules/v4/reward").RewardService["getByRecipient"]>>;
+                                }, "rewards"> & {
+                                    rewards: (Omit<{
+                                        token: {
+                                            id: string;
+                                            name: string | null;
+                                            chainId: number;
+                                            address: string;
+                                            decimals: number;
+                                            symbol: string;
+                                            icon: string;
+                                            verified: boolean;
+                                            price: number | null;
+                                        };
+                                        breakdowns: {
+                                            campaignId: string;
+                                            opportunity: {
+                                                Chain: {
+                                                    id: number;
+                                                    name: string;
+                                                    icon: string;
+                                                };
+                                                Tokens: {
+                                                    id: string;
+                                                    name: string | null;
+                                                    chainId: number;
+                                                    address: string;
+                                                    decimals: number;
+                                                    symbol: string;
+                                                    icon: string;
+                                                    verified: boolean;
+                                                    price: number | null;
+                                                }[];
+                                                Protocols: {
+                                                    id: string;
+                                                    tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                                    name: string;
+                                                    description: string;
+                                                    url: string;
+                                                    icon: string;
+                                                }[];
+                                                MainProtocol: {
+                                                    id: string;
+                                                    tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                                    name: string;
+                                                    description: string;
+                                                    url: string;
+                                                    icon: string;
+                                                } | null;
+                                            } & {
+                                                id: string;
+                                                chainId: number;
+                                                type: import("../../database/api/.generated").$Enums.CampaignType;
+                                                identifier: string;
+                                                name: string;
+                                                status: import("../../database/api/.generated").$Enums.Status;
+                                                action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                                                mainProtocolId: string | null;
+                                                tvl: number;
+                                                apr: number;
+                                                dailyRewards: number;
+                                                tags: string[];
+                                            };
+                                            reason: string;
+                                            amount: string;
+                                            claimed: string;
+                                            pending: string;
+                                            auxiliaryData1: string | null;
+                                            auxiliaryData2: string | null;
+                                        }[];
+                                        claimed: bigint;
+                                        amount: bigint;
+                                        pending: bigint;
+                                        root: string;
+                                        recipient: string;
+                                        proofs: string[];
+                                    }, "breakdowns"> & {
+                                        breakdowns: {
+                                            opportunity: import("../modules/v4").Opportunity["model"] | null;
+                                            claimed: bigint;
+                                            amount: bigint;
+                                            pending: bigint;
+                                            auxiliaryData1: string | null;
+                                            auxiliaryData2: string | null;
+                                        }[];
+                                    })[];
+                                    distributor: string;
+                                })[];
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        users: {
+            ":address": {
+                rewards: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            address: string;
+                        };
+                        query: {
+                            chainId: number | number[];
+                        };
+                        headers: unknown;
+                        response: {
+                            200: (Omit<{
+                                chain: import("../../database/api/.generated").Chain;
+                                rewards: Awaited<ReturnType<typeof import("../modules/v4/reward").RewardService["getByRecipient"]>>;
+                            }, "rewards"> & {
+                                rewards: (Omit<{
+                                    token: {
+                                        id: string;
+                                        name: string | null;
+                                        chainId: number;
+                                        address: string;
+                                        decimals: number;
+                                        symbol: string;
+                                        icon: string;
+                                        verified: boolean;
+                                        price: number | null;
+                                    };
+                                    breakdowns: {
+                                        campaignId: string;
+                                        opportunity: {
+                                            Chain: {
+                                                id: number;
+                                                name: string;
+                                                icon: string;
+                                            };
+                                            Tokens: {
+                                                id: string;
+                                                name: string | null;
+                                                chainId: number;
+                                                address: string;
+                                                decimals: number;
+                                                symbol: string;
+                                                icon: string;
+                                                verified: boolean;
+                                                price: number | null;
+                                            }[];
+                                            Protocols: {
+                                                id: string;
+                                                tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                                name: string;
+                                                description: string;
+                                                url: string;
+                                                icon: string;
+                                            }[];
+                                            MainProtocol: {
+                                                id: string;
+                                                tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                                name: string;
+                                                description: string;
+                                                url: string;
+                                                icon: string;
+                                            } | null;
+                                        } & {
+                                            id: string;
+                                            chainId: number;
+                                            type: import("../../database/api/.generated").$Enums.CampaignType;
+                                            identifier: string;
+                                            name: string;
+                                            status: import("../../database/api/.generated").$Enums.Status;
+                                            action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                                            mainProtocolId: string | null;
+                                            tvl: number;
+                                            apr: number;
+                                            dailyRewards: number;
+                                            tags: string[];
+                                        };
+                                        reason: string;
+                                        amount: string;
+                                        claimed: string;
+                                        pending: string;
+                                        auxiliaryData1: string | null;
+                                        auxiliaryData2: string | null;
+                                    }[];
+                                    claimed: bigint;
+                                    amount: bigint;
+                                    pending: bigint;
+                                    root: string;
+                                    recipient: string;
+                                    proofs: string[];
+                                }, "breakdowns"> & {
+                                    breakdowns: {
+                                        campaignId: string;
+                                        reason: string;
+                                        amount: string;
+                                        claimed: string;
+                                        pending: string;
+                                        auxiliaryData1: string | null;
+                                        auxiliaryData2: string | null;
+                                    }[];
+                                })[];
+                            })[];
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        users: {
+            index: {
+                post: {
+                    body: {
+                        tags: string[];
+                        address: string;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            address: string;
+                            tags: string[];
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        users: {
+            ":address": {
+                tags: {
+                    patch: {
+                        body: {
+                            tags: string[];
+                        };
+                        params: {
+                            address: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: {
+                                address: string;
+                                tags: string[];
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        roots: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        chainId: number;
+                        fromTimestamp: string;
+                        toTimestamp: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            root: string;
+                            chainId: number;
+                            epoch: number;
+                            timestamp: bigint;
+                        }[];
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        participate: {
+            targets: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        identifier?: string | undefined;
+                        chainId: number;
+                        protocolId: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: import("../modules/v4/participate/participate.model").ParticipateTarget[] | undefined;
+                    };
+                };
+            };
+        };
+    } & {
+        participate: {
+            protocols: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        chainId?: number | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            name: string;
+                            url: string;
+                            description: string;
+                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                            icon: string;
+                        } & {})[] | null;
+                    };
+                };
+            };
+        };
+    } & {
+        participate: {
+            quote: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        identifier: string;
+                        chainId: number;
+                        protocolId: string;
+                        userAddress: string;
+                        fromAmount: string;
+                        fromTokenAddress: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            amountOut: {};
+                            gas: string;
+                            feeAmount: string[];
+                            priceImpact: number;
+                        } | undefined;
+                    };
+                };
+            };
+        };
+    } & {
+        participate: {
+            transaction: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        identifier: string;
+                        chainId: number;
+                        protocolId: string;
+                        userAddress: string;
+                        fromAmount: string;
+                        fromTokenAddress: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            amountOut: string;
+                            gas: string;
+                            feeAmount: string[];
+                            priceImpact: number;
+                            createAt: number;
+                            tx: {
+                                data: string;
+                                from: string;
+                                value: string;
+                                to: string;
+                            };
+                        } | undefined;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        accounting: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        items?: number | undefined;
+                        page?: number | undefined;
+                    };
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            id: string;
+                            chainId: number;
+                            fromTokenId: string;
+                            toTokenId: string;
+                            multisig: string;
+                            recipient: string;
+                            amountIn: string;
+                            amountOut: string;
+                            datetime: Date;
+                            timestamp: number;
+                        }[];
+                    };
+                };
+            };
+        } & {
+            revenues: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            totalAmount: number;
+                        };
+                    };
+                };
+            };
+        } & {
+            revenues: {
+                "per-month": {
+                    ":year": {
+                        ":month": {
+                            get: {
+                                body: unknown;
+                                params: {
+                                    month: number;
+                                    year: number;
+                                };
+                                query: unknown;
+                                headers: {
+                                    authorization: string;
+                                };
+                                response: {
+                                    200: {
+                                        totalAmount: number;
+                                        from: string;
+                                        to: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            revenues: {
+                chains: {
+                    ":chainId": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                chainId: number;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: {
+                                    totalAmount: number;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            revenues: {
+                chains: {
+                    ":chainId": {
+                        "per-month": {
+                            ":year": {
+                                ":month": {
+                                    get: {
+                                        body: unknown;
+                                        params: {
+                                            chainId: number;
+                                            month: number;
+                                            year: number;
+                                        };
+                                        query: unknown;
+                                        headers: {
+                                            authorization: string;
+                                        };
+                                        response: {
+                                            200: {
+                                                totalAmount: number;
+                                                from: string;
+                                                to: string;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            tokens: {
+                ":chainId": {
+                    ":tokenAddress": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                chainId: number;
+                                tokenAddress: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: {
+                                    totalAmount: number;
+                                    totalAmountUSD: number;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            tokens: {
+                ":chainId": {
+                    ":tokenAddress": {
+                        "per-month": {
+                            ":year": {
+                                ":month": {
+                                    get: {
+                                        body: unknown;
+                                        params: {
+                                            chainId: number;
+                                            tokenAddress: string;
+                                            month: number;
+                                            year: number;
+                                        };
+                                        query: unknown;
+                                        headers: {
+                                            authorization: string;
+                                        };
+                                        response: {
+                                            200: {
+                                                totalAmount: number;
+                                                totalAmountUSD: number;
+                                                from: string;
+                                                to: string;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v4: {
+        campaignStatus: {
+            engine: {
+                post: {
+                    body: {
+                        status: {
+                            value: "SUCCESS";
+                            computedUntil: number;
+                        } | {
+                            value: "PROCESSING";
+                        } | {
+                            error: string;
+                            details: string;
+                            value: "SKIPPED";
+                        } | {
+                            error: string;
+                            details: string;
+                            value: "FAILED";
+                        };
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../database/api/.generated").Prisma.JsonValue;
+                        }[];
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            unique: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        identifier: string;
+                        distributionChain: number;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../database/api/.generated").Prisma.JsonValue;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            computeChain: {
+                ":chainId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            chainId: number;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                campaignId: string;
+                                computedUntil: bigint;
+                                processingStarted: bigint;
+                                status: import("../../database/api/.generated").$Enums.RunStatus;
+                                error: string;
+                                details: import("../../database/api/.generated").Prisma.JsonValue;
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            overlaps: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        identifier: string;
+                        distributionChain: number;
+                    };
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: boolean;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {
+        readonly tracer: import("dd-trace").Tracer;
+        readonly span: import("dd-trace").Span;
+        readonly trace: <R, T extends () => R>(handler: T) => R;
+    };
+    resolve: {};
+    schema: {};
+}>, config?: import("@elysiajs/eden").Treaty.Config) => {
+    valueOf: {};
+    index: {
+        get: (options?: {
+            headers?: Record<string, unknown> | undefined;
+            query?: Record<string, unknown> | undefined;
+            fetch?: RequestInit | undefined;
+        } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+            200: string;
+        }>>;
+    };
+    v4: {
+        opportunities: ((params: {
+            id: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: {
+                    aprRecord: {
+                        cumulated: number;
+                        cummulated: number;
+                        timestamp: bigint;
+                        breakdowns: {
+                            id: number;
+                            identifier: string;
+                            type: import("../../database/api/.generated").$Enums.AprType;
+                            value: number;
+                            aprRecordId: string;
+                        }[];
+                    };
+                    tvlRecord: {
+                        id: string;
+                        total: number;
+                        timestamp: bigint;
+                        breakdowns: {
+                            id: number;
+                            identifier: string;
+                            type: import("../../database/api/.generated").$Enums.TvlType;
+                            value: number;
+                            tvlRecordId: string;
+                        }[];
+                    };
+                    rewardsRecord: {
+                        id: string;
+                        total: number;
+                        timestamp: bigint;
+                        breakdowns: {
+                            id: number;
+                            value: number;
+                            campaignId: string;
+                            dailyRewardsRecordId: string;
+                        }[];
+                    };
+                    id: string;
+                    tokens: {
+                        id: string;
+                        name: string | null;
+                        chainId: number;
+                        address: string;
+                        decimals: number;
+                        symbol: string;
+                        icon: string;
+                        verified: boolean;
+                        price: number | null;
+                    }[];
+                    chain: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    };
+                    protocol: {
+                        id: string;
+                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    } | undefined;
+                    name: string;
+                    type: import("../../database/api/.generated").$Enums.CampaignType;
+                    status: import("../../database/api/.generated").$Enums.Status;
+                    tags: string[];
+                    identifier: string;
+                    chainId: number;
+                    action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                    tvl: number;
+                    apr: number;
+                    dailyRewards: number;
+                } | null | undefined;
+            }>>;
+            campaigns: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        aprRecord: {
+                            cumulated: number;
+                            cummulated: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                identifier: string;
+                                type: import("../../database/api/.generated").$Enums.AprType;
+                                value: number;
+                                aprRecordId: string;
+                            }[];
+                        };
+                        tvlRecord: {
+                            id: string;
+                            total: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                identifier: string;
+                                type: import("../../database/api/.generated").$Enums.TvlType;
+                                value: number;
+                                tvlRecordId: string;
+                            }[];
+                        };
+                        rewardsRecord: {
+                            id: string;
+                            total: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                value: number;
+                                campaignId: string;
+                                dailyRewardsRecordId: string;
+                            }[];
+                        };
+                        id: string;
+                        tokens: {
+                            id: string;
+                            name: string | null;
+                            chainId: number;
+                            address: string;
+                            decimals: number;
+                            symbol: string;
+                            icon: string;
+                            verified: boolean;
+                            price: number | null;
+                        }[];
+                        chain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        };
+                        protocol: {
+                            id: string;
+                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                            name: string;
+                            description: string;
+                            url: string;
+                            icon: string;
+                        } | undefined;
+                        name: string;
+                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                        status: import("../../database/api/.generated").$Enums.Status;
+                        tags: string[];
+                        identifier: string;
+                        chainId: number;
+                        action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                        tvl: number;
+                        apr: number;
+                        dailyRewards: number;
+                    } | null | undefined;
+                }>>;
+            };
+        }) & {
+            index: {
+                post: (body: {
+                    name?: string | undefined;
+                    type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4";
+                    tokens: {
+                        chainId: number;
+                        address: string;
+                    }[];
+                    status: "NONE" | "PAST" | "LIVE" | "SOON";
+                    identifier: string;
+                    chainId: number;
+                    action: "INVALID" | "POOL" | "HOLD" | "DROP" | "LEND" | "BORROW";
+                    protocols: string[];
+                    mainProtocol: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        sort?: "tvl" | "apr" | "rewards" | undefined;
+                        name?: string | undefined;
+                        tokens?: string | undefined;
+                        status?: string | undefined;
+                        items?: number | undefined;
+                        tags?: string | undefined;
+                        chainId?: string | undefined;
+                        page?: number | undefined;
+                        action?: string | undefined;
+                        mainProtocolId?: string | undefined;
+                        order?: "asc" | "desc" | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        aprRecord: {
+                            cumulated: number;
+                            cummulated: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                identifier: string;
+                                type: import("../../database/api/.generated").$Enums.AprType;
+                                value: number;
+                                aprRecordId: string;
+                            }[];
+                        };
+                        tvlRecord: {
+                            id: string;
+                            total: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                identifier: string;
+                                type: import("../../database/api/.generated").$Enums.TvlType;
+                                value: number;
+                                tvlRecordId: string;
+                            }[];
+                        };
+                        rewardsRecord: {
+                            id: string;
+                            total: number;
+                            timestamp: bigint;
+                            breakdowns: {
+                                id: number;
+                                value: number;
+                                campaignId: string;
+                                dailyRewardsRecordId: string;
+                            }[];
+                        };
+                        id: string;
+                        tokens: {
+                            id: string;
+                            name: string | null;
+                            chainId: number;
+                            address: string;
+                            decimals: number;
+                            symbol: string;
+                            icon: string;
+                            verified: boolean;
+                            price: number | null;
+                        }[];
+                        chain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        };
+                        protocol: {
+                            id: string;
+                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                            name: string;
+                            description: string;
+                            url: string;
+                            icon: string;
+                        } | undefined;
+                        name: string;
+                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                        status: import("../../database/api/.generated").$Enums.Status;
+                        tags: string[];
+                        identifier: string;
+                        chainId: number;
+                        action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                        tvl: number;
+                        apr: number;
+                        dailyRewards: number;
+                    } | null)[];
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        sort?: "tvl" | "apr" | "rewards" | undefined;
+                        name?: string | undefined;
+                        tokens?: string | undefined;
+                        status?: string | undefined;
+                        items?: number | undefined;
+                        tags?: string | undefined;
+                        chainId?: string | undefined;
+                        page?: number | undefined;
+                        action?: string | undefined;
+                        mainProtocolId?: string | undefined;
+                        order?: "asc" | "desc" | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        campaigns: {
+            index: {
+                post: (body: {
+                    subType?: number | undefined;
+                    type: number;
+                    params: string;
+                    identifier: string;
+                    chainId: number;
+                    startTimestamp: string;
+                    endTimestamp: string;
+                    computeChainId: number;
+                    campaignId: string;
+                    amount: string;
+                    creator: string;
+                    rewardTokenAddress: string;
+                    opportunityIdentifier: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: unknown;
+                }>>;
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
+                        items?: number | undefined;
+                        identifier?: string | undefined;
+                        subType?: number | undefined;
+                        chainId?: number | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        page?: number | undefined;
+                        mainParameter?: string | undefined;
+                        campaignId?: string | undefined;
+                        opportunityId?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        params: any;
+                        chain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        };
+                        rewardToken: {
+                            id: string;
+                            name: string | null;
+                            chainId: number;
+                            address: string;
+                            decimals: number;
+                            symbol: string;
+                            icon: string;
+                            verified: boolean;
+                            price: number | null;
+                        };
+                        distributionChain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        } | undefined;
+                        id: string;
+                        computeChainId: number;
+                        distributionChainId: number;
+                        identifier: string;
+                        campaignId: string;
+                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                        subType: number | null;
+                        rewardTokenId: string;
+                        amount: string;
+                        opportunityId: string;
+                        startTimestamp: bigint;
+                        endTimestamp: bigint;
+                        creatorAddress: string;
+                    } | null)[];
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
+                        items?: number | undefined;
+                        identifier?: string | undefined;
+                        subType?: number | undefined;
+                        chainId?: number | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        page?: number | undefined;
+                        mainParameter?: string | undefined;
+                        campaignId?: string | undefined;
+                        opportunityId?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        protocols: ((params: {
+            id: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: ({
+                    name: string;
+                    url: string;
+                    description: string;
+                    tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                    icon: string;
+                } & {}) | null;
+            }>>;
+        }) & {
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        name?: string | undefined;
+                        id?: string[] | undefined;
+                        items?: number | undefined;
+                        tags?: ("AMM" | "ALM" | "DEX" | "LENDING")[] | undefined;
+                        page?: number | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        name: string;
+                        url: string;
+                        description: string;
+                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                        icon: string;
+                    } & {})[] | null;
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        name?: string | undefined;
+                        id?: string[] | undefined;
+                        items?: number | undefined;
+                        tags?: ("AMM" | "ALM" | "DEX" | "LENDING")[] | undefined;
+                        page?: number | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        tokens: ((params: {
+            id: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: ({
+                    symbol: string;
+                    name: string | null;
+                    id: string;
+                    chainId: number;
+                    address: string;
+                    icon: string;
+                    decimals: number;
+                    verified: boolean;
+                } & {
+                    price?: number | null | undefined;
+                }) | undefined;
+            }>>;
+        }) & {
+            balances: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        tokenAddress?: string | undefined;
+                        additionalTokenAddresses?: string[] | undefined;
+                        chainId: number;
+                        userAddress: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        symbol: string;
+                        name: string | null;
+                        id: string;
+                        chainId: number;
+                        address: string;
+                        icon: string;
+                        decimals: number;
+                        verified: boolean;
+                    } & {
+                        price?: number | null | undefined;
+                    } & {
+                        balance: bigint;
+                    })[];
+                }>>;
+            };
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        symbol?: string | undefined;
+                        name?: string | undefined;
+                        chainId?: any;
+                        address?: string | undefined;
+                        verified?: boolean | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        symbol: string;
+                        name: string | null;
+                        id: string;
+                        chainId: number;
+                        address: string;
+                        icon: string;
+                        decimals: number;
+                        verified: boolean;
+                    } & {
+                        price?: number | null | undefined;
+                    })[];
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        symbol?: string | undefined;
+                        name?: string | undefined;
+                        chainId?: any;
+                        address?: string | undefined;
+                        verified?: boolean | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        rewards: {
+            engine: {
+                post: (body: {
+                    recipient: string;
+                    distributionChainId: number;
+                    root: string;
+                    proofs: string[];
+                    rewardToken: string;
+                }[], options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: import("../../database/api/.generated").Prisma.BatchPayload;
+                }>>;
+                breakdowns: {
+                    post: (body: {
+                        distributionChainId: number;
+                        campaignId: string;
+                        root: string;
+                        rewardToken: string;
+                        breakdowns: {
+                            protocolId?: string | undefined;
+                            auxiliaryData1?: string | undefined;
+                            auxiliaryData2?: string | undefined;
+                            reason: string;
+                            pending: string;
+                            recipient: string;
+                            amount: string;
+                            claimed: string;
+                        }[];
+                    }[], options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: import("../../database/api/.generated").Prisma.BatchPayload;
+                    }>>;
+                };
+            };
+            pendings: {
+                post: (body: {
+                    distributionChainId: number;
+                    campaignId: string;
+                    root: string;
+                    rewardToken: string;
+                    toUpdate: {
+                        auxiliaryData1?: string | undefined;
+                        auxiliaryData2?: string | undefined;
+                        reason: string;
+                        pending: string;
+                        recipient: string;
+                    }[];
+                    toCreate: {
+                        auxiliaryData1?: string | undefined;
+                        auxiliaryData2?: string | undefined;
+                        reason: string;
+                        pending: string;
+                        recipient: string;
+                    }[];
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: Record<string, {
+                        breakdown: number;
+                        rewards: Record<string, number>;
+                    }>;
+                }>>;
+            };
+            breakdown: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        items?: number | undefined;
+                        page?: number | undefined;
+                        chainId: number;
+                        campaignIdentifiers: string | string[];
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        Campaign: {
+                            identifier: string;
+                            campaignId: string;
+                        };
+                        amount: string;
+                        Reward: {
+                            recipient: string;
+                        };
+                    }[];
+                }>>;
+            };
+        };
+        chains: ((params: {
+            chainId: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: ({
+                    Explorer: {
+                        id: string;
+                        type: import("../../database/api/.generated").$Enums.ExplorerType;
+                        url: string;
+                        chainId: number;
+                    }[];
+                } & {
+                    id: number;
+                    name: string;
+                    icon: string;
+                }) | null;
+            }>>;
+        }) & {
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        search?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        Explorer: {
+                            id: string;
+                            type: import("../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            chainId: number;
+                        }[];
+                    } & {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    })[];
+                }>>;
+            };
+            count: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        search?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            };
+        };
+        prices: {
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        [token: string]: number;
+                    };
+                }>>;
+            };
+            symbol: ((params: {
+                symbol: string | number;
+            }) => {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: number;
+                }>>;
+            }) & {};
+            sources: {
+                index: {
+                    get: (options?: {
+                        headers?: Record<string, unknown> | undefined;
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            id: number;
+                            symbol: string;
+                            method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                            args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                        }[];
+                    }>>;
+                    post: (body: {
+                        symbol: string;
+                        method: "COINGECKO" | "CONSTANT" | "EQUAL_TO" | "ERC4626" | "DEXSCREENER" | "INDEXCOOP" | "DEFILLAMA";
+                        args: {};
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: number | undefined;
+                    }>>;
+                };
+                symbol: ((params: {
+                    symbol: string | number;
+                }) => {
+                    get: (options?: {
+                        headers?: Record<string, unknown> | undefined;
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            id: number;
+                            symbol: string;
+                            method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                            args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                        };
+                    }>>;
+                    patch: (body: {
+                        symbol?: string | undefined;
+                        method?: "COINGECKO" | "CONSTANT" | "EQUAL_TO" | "ERC4626" | "DEXSCREENER" | "INDEXCOOP" | "DEFILLAMA" | undefined;
+                        args?: {} | undefined;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            id: number;
+                            symbol: string;
+                            method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                            args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                        };
+                    }>>;
+                    delete: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            id: number;
+                            symbol: string;
+                            method: import("../../database/api/.generated").$Enums.PriceSourceMethod;
+                            args: import("../../database/api/.generated").Prisma.JsonValue | null;
+                        };
+                    }>>;
+                }) & {};
+            };
+        };
+        blacklists: {
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        id: string;
+                        chainId: number;
+                        poolAddress: string;
+                        userAddress: string;
+                        arrestTimestamp: bigint;
+                        arrestDetails: import("../../database/api/.generated").Prisma.JsonValue;
+                    }[];
+                }>>;
+                post: (body: {
+                    reason?: string | undefined;
+                    chainId: number;
+                    poolAddress: string;
+                    userAddress: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        id: string;
+                        chainId: number;
+                        poolAddress: string;
+                        userAddress: string;
+                        arrestTimestamp: bigint;
+                        arrestDetails: import("../../database/api/.generated").Prisma.JsonValue;
+                    };
+                }>>;
+            };
+            all: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: string[];
+                }>>;
+            };
+            check: ((params: {
+                address: string | number;
+            }) => {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            }) & {};
+            user: ((params: {
+                address: string | number;
+            }) => {
+                delete: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            }) & {};
+        };
+        users: ((params: {
+            address: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: {
+                    address: string;
+                } | null;
+            }>>;
+            rewards: {
+                full: {
+                    get: (options?: {
+                        headers?: Record<string, unknown> | undefined;
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: (Omit<{
+                            chain: import("../../database/api/.generated").Chain;
+                            rewards: Awaited<ReturnType<typeof import("../modules/v4/reward").RewardService["getByRecipient"]>>;
+                        }, "rewards"> & {
+                            rewards: (Omit<{
+                                token: {
+                                    id: string;
+                                    name: string | null;
+                                    chainId: number;
+                                    address: string;
+                                    decimals: number;
+                                    symbol: string;
+                                    icon: string;
+                                    verified: boolean;
+                                    price: number | null;
+                                };
+                                breakdowns: {
+                                    campaignId: string;
+                                    opportunity: {
+                                        Chain: {
+                                            id: number;
+                                            name: string;
+                                            icon: string;
+                                        };
+                                        Tokens: {
+                                            id: string;
+                                            name: string | null;
+                                            chainId: number;
+                                            address: string;
+                                            decimals: number;
+                                            symbol: string;
+                                            icon: string;
+                                            verified: boolean;
+                                            price: number | null;
+                                        }[];
+                                        Protocols: {
+                                            id: string;
+                                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                            name: string;
+                                            description: string;
+                                            url: string;
+                                            icon: string;
+                                        }[];
+                                        MainProtocol: {
+                                            id: string;
+                                            tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                            name: string;
+                                            description: string;
+                                            url: string;
+                                            icon: string;
+                                        } | null;
+                                    } & {
+                                        id: string;
+                                        chainId: number;
+                                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                                        identifier: string;
+                                        name: string;
+                                        status: import("../../database/api/.generated").$Enums.Status;
+                                        action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                                        mainProtocolId: string | null;
+                                        tvl: number;
+                                        apr: number;
+                                        dailyRewards: number;
+                                        tags: string[];
+                                    };
+                                    reason: string;
+                                    amount: string;
+                                    claimed: string;
+                                    pending: string;
+                                    auxiliaryData1: string | null;
+                                    auxiliaryData2: string | null;
+                                }[];
+                                claimed: bigint;
+                                amount: bigint;
+                                pending: bigint;
+                                root: string;
+                                recipient: string;
+                                proofs: string[];
+                            }, "breakdowns"> & {
+                                breakdowns: {
+                                    opportunity: import("../modules/v4").Opportunity["model"] | null;
+                                    claimed: bigint;
+                                    amount: bigint;
+                                    pending: bigint;
+                                    auxiliaryData1: string | null;
+                                    auxiliaryData2: string | null;
+                                }[];
+                            })[];
+                            distributor: string;
+                        })[];
+                    }>>;
+                };
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        chainId: number | number[];
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: (Omit<{
+                        chain: import("../../database/api/.generated").Chain;
+                        rewards: Awaited<ReturnType<typeof import("../modules/v4/reward").RewardService["getByRecipient"]>>;
+                    }, "rewards"> & {
+                        rewards: (Omit<{
+                            token: {
+                                id: string;
+                                name: string | null;
+                                chainId: number;
+                                address: string;
+                                decimals: number;
+                                symbol: string;
+                                icon: string;
+                                verified: boolean;
+                                price: number | null;
+                            };
+                            breakdowns: {
+                                campaignId: string;
+                                opportunity: {
+                                    Chain: {
+                                        id: number;
+                                        name: string;
+                                        icon: string;
+                                    };
+                                    Tokens: {
+                                        id: string;
+                                        name: string | null;
+                                        chainId: number;
+                                        address: string;
+                                        decimals: number;
+                                        symbol: string;
+                                        icon: string;
+                                        verified: boolean;
+                                        price: number | null;
+                                    }[];
+                                    Protocols: {
+                                        id: string;
+                                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                        name: string;
+                                        description: string;
+                                        url: string;
+                                        icon: string;
+                                    }[];
+                                    MainProtocol: {
+                                        id: string;
+                                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                                        name: string;
+                                        description: string;
+                                        url: string;
+                                        icon: string;
+                                    } | null;
+                                } & {
+                                    id: string;
+                                    chainId: number;
+                                    type: import("../../database/api/.generated").$Enums.CampaignType;
+                                    identifier: string;
+                                    name: string;
+                                    status: import("../../database/api/.generated").$Enums.Status;
+                                    action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                                    mainProtocolId: string | null;
+                                    tvl: number;
+                                    apr: number;
+                                    dailyRewards: number;
+                                    tags: string[];
+                                };
+                                reason: string;
+                                amount: string;
+                                claimed: string;
+                                pending: string;
+                                auxiliaryData1: string | null;
+                                auxiliaryData2: string | null;
+                            }[];
+                            claimed: bigint;
+                            amount: bigint;
+                            pending: bigint;
+                            root: string;
+                            recipient: string;
+                            proofs: string[];
+                        }, "breakdowns"> & {
+                            breakdowns: {
+                                campaignId: string;
+                                reason: string;
+                                amount: string;
+                                claimed: string;
+                                pending: string;
+                                auxiliaryData1: string | null;
+                                auxiliaryData2: string | null;
+                            }[];
+                        })[];
+                    })[];
+                }>>;
+            };
+            tags: {
+                patch: (body: {
+                    tags: string[];
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        address: string;
+                        tags: string[];
+                    };
+                }>>;
+            };
+        }) & {
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        items?: number | undefined;
+                        tags?: string[] | undefined;
+                        page?: number | undefined;
+                        address?: string | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        address: string;
+                        tags: string[];
+                    }[];
+                }>>;
+                post: (body: {
+                    tags: string[];
+                    address: string;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        address: string;
+                        tags: string[];
+                    };
+                }>>;
+            };
+        };
+        roots: {
+            index: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        chainId: number;
+                        fromTimestamp: string;
+                        toTimestamp: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        root: string;
+                        chainId: number;
+                        epoch: number;
+                        timestamp: bigint;
+                    }[];
+                }>>;
+            };
+        };
+        participate: {
+            targets: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        identifier?: string | undefined;
+                        chainId: number;
+                        protocolId: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: import("../modules/v4/participate/participate.model").ParticipateTarget[] | undefined;
+                }>>;
+            };
+            protocols: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        chainId?: number | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        name: string;
+                        url: string;
+                        description: string;
+                        tags: import("../../database/api/.generated").$Enums.ProtocolTag[];
+                        icon: string;
+                    } & {})[] | null;
+                }>>;
+            };
+            quote: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        identifier: string;
+                        chainId: number;
+                        protocolId: string;
+                        userAddress: string;
+                        fromAmount: string;
+                        fromTokenAddress: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        amountOut: {};
+                        gas: string;
+                        feeAmount: string[];
+                        priceImpact: number;
+                    } | undefined;
+                }>>;
+            };
+            transaction: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        identifier: string;
+                        chainId: number;
+                        protocolId: string;
+                        userAddress: string;
+                        fromAmount: string;
+                        fromTokenAddress: string;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        amountOut: string;
+                        gas: string;
+                        feeAmount: string[];
+                        priceImpact: number;
+                        createAt: number;
+                        tx: {
+                            data: string;
+                            from: string;
+                            value: string;
+                            to: string;
+                        };
+                    } | undefined;
+                }>>;
+            };
+        };
+        accounting: {
+            index: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query: {
+                        items?: number | undefined;
+                        page?: number | undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        id: string;
+                        chainId: number;
+                        fromTokenId: string;
+                        toTokenId: string;
+                        multisig: string;
+                        recipient: string;
+                        amountIn: string;
+                        amountOut: string;
+                        datetime: Date;
+                        timestamp: number;
+                    }[];
+                }>>;
+            };
+            revenues: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        totalAmount: number;
+                    };
+                }>>;
+                "per-month": ((params: {
+                    year: string | number;
+                }) => {} & ((params: {
+                    month: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            totalAmount: number;
+                            from: string;
+                            to: string;
+                        };
+                    }>>;
+                })) & {};
+                chains: ((params: {
+                    chainId: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            totalAmount: number;
+                        };
+                    }>>;
+                    "per-month": ((params: {
+                        year: string | number;
+                    }) => {} & ((params: {
+                        month: string | number;
+                    }) => {
+                        get: (options: {
+                            headers: {
+                                authorization: string;
+                            };
+                            query?: Record<string, unknown> | undefined;
+                            fetch?: RequestInit | undefined;
+                        }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                            200: {
+                                totalAmount: number;
+                                from: string;
+                                to: string;
+                            };
+                        }>>;
+                    })) & {};
+                }) & {};
+            };
+            tokens: ((params: {
+                chainId: string | number;
+            }) => {} & ((params: {
+                tokenAddress: string | number;
+            }) => {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        totalAmount: number;
+                        totalAmountUSD: number;
+                    };
+                }>>;
+                "per-month": ((params: {
+                    year: string | number;
+                }) => {} & ((params: {
+                    month: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            totalAmount: number;
+                            totalAmountUSD: number;
+                            from: string;
+                            to: string;
+                        };
+                    }>>;
+                })) & {};
+            })) & {};
+        };
+        campaignStatus: {
+            engine: {
+                post: (body: {
+                    status: {
+                        value: "SUCCESS";
+                        computedUntil: number;
+                    } | {
+                        value: "PROCESSING";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "SKIPPED";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "FAILED";
+                    };
+                    campaignId: string;
+                    distributionChain: number;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    }[];
+                }>>;
+            };
+            unique: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        identifier: string;
+                        distributionChain: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    };
+                }>>;
+            };
+            computeChain: ((params: {
+                chainId: string | number;
+            }) => {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    }[];
+                }>>;
+            }) & {};
+            overlaps: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query: {
+                        identifier: string;
+                        distributionChain: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            };
+        };
+    };
+};
+export type Opportunity = FromPromise<Api["v4"]["opportunities"]["index"]["get"]>;
+export type Protocol = FromPromise<Api["v4"]["protocols"]["index"]["get"]>;
+export type Campaign<C extends CampaignType = CampaignType> = CampaignResource<C>["model"];
+export type Chain = FromPromise<Api["v4"]["chains"]["index"]["get"]>;
+export type Token = FromPromise<Api["v4"]["tokens"]["index"]["get"]>;
+export type Reward = NonNullable<Awaited<ReturnType<ReturnType<Api["v4"]["users"]>["rewards"]["full"]["get"]>>["data"]>[number];
+export {};