@merkl/api 0.10.78

package/dist/src/routes/v3/ERC20Campaigns.d.ts

@@ -0,0 +1,1910 @@
+import type { App } from "../../index";
+import { UnsupportedNetwork } from "../../utils/error";
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    types: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>, import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    live: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    creatorTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const response: import("@sinclair/typebox").TObject<{}>;
+declare const _default: (app: App) => 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: 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;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    index: {
+        get: {
+            body: unknown;
+            params: Record<never, string>;
+            query: {
+                chainIds?: string | string[] | undefined;
+            };
+            headers: unknown;
+            response: {
+                200: unknown;
+            };
+        };
+    };
+}, {
+    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: {};
+}>;
+export default _default;