@merkl/api 0.10.78

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

@@ -0,0 +1,15 @@
+import type { Resource } from "../prisma";
+/**
+ * Tvl Record
+ * @description Describes one tvl snapshot for an opportunity
+ * @see {@link Resource}
+ */
+export type TvlRecord = Resource<"TVLRecord", "id" | "opportunityId", {
+    breakdowns: TvlBreakdown["model"][];
+}>;
+/**
+ * Tvl Breakdown
+ * @description Describes one tvl fraction of record
+ * @see {@link Resource}
+ */
+export type TvlBreakdown = Resource<"TVLBreakdown", "id" | "tvlRecordId">;

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+export declare const UniswapV4PoolsDto: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+    poolKey: import("@sinclair/typebox").TObject<{
+        currency0: import("@sinclair/typebox").TString;
+        currency1: import("@sinclair/typebox").TString;
+        fee: import("@sinclair/typebox").TNumber;
+        tickSpacing: import("@sinclair/typebox").TNumber;
+        hooks: import("@sinclair/typebox").TString;
+    }>;
+    poolId: import("@sinclair/typebox").TString;
+    decimalsCurrency0: import("@sinclair/typebox").TNumber;
+    decimalsCurrency1: import("@sinclair/typebox").TNumber;
+    symbolCurrency0: import("@sinclair/typebox").TString;
+    symbolCurrency1: import("@sinclair/typebox").TString;
+}>>;
+export type UniswapV4PoolsEntity = typeof UniswapV4PoolsDto.static;

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

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

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

@@ -0,0 +1,20 @@
+import { type MerklChainId } from "@sdk";
+export declare const PoolManagerInterface: any;
+export declare abstract class UniswapV4Service {
+    static getPoolsByChain(chainId: MerklChainId): Promise<{
+        [x: string]: {
+            poolId: string;
+            poolKey: {
+                hooks: string;
+                fee: number;
+                tickSpacing: number;
+                currency0: string;
+                currency1: string;
+            };
+            decimalsCurrency0: number;
+            decimalsCurrency1: number;
+            symbolCurrency0: string;
+            symbolCurrency1: string;
+        };
+    }>;
+}

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

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

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

@@ -0,0 +1,325 @@
+import { Elysia } from "elysia";
+import { RewardService } from "../reward";
+export declare const UserController: Elysia<"/users", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    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 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("..").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 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[];
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,25 @@
+import type { Resource } from "../prisma";
+/**
+ * User
+ * @description A user represented by its address
+ * @see {@link Resource}
+ */
+export type User = Resource<"User">;
+export declare const UserUniqueDto: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare const UserDto: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+}>;
+export declare const GetManyUserQuery: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const UpdateUserTagsDto: import("@sinclair/typebox").TObject<{
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+}>;
+export type UserModel = typeof UserDto.static;
+export type GetManyUserModel = typeof GetManyUserQuery.static;

package/dist/src/modules/v4/user/user.repository.d.ts

@@ -0,0 +1,19 @@
+import type { GetManyUserModel, UserModel } from "./user.model";
+export declare abstract class UserRepository {
+    static findUnique(address: string): Promise<{
+        address: string;
+    } | null>;
+    static findMany(query: GetManyUserModel): Promise<{
+        address: string;
+        tags: string[];
+    }[]>;
+    static create(user: UserModel): Promise<{
+        address: string;
+        tags: string[];
+    }>;
+    static createMany(users: UserModel[]): Promise<import("../../../../database/api/.generated").Prisma.BatchPayload>;
+    static updateTags(address: string, tags: string[]): Promise<{
+        address: string;
+        tags: string[];
+    }>;
+}

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

@@ -0,0 +1,19 @@
+import type { GetManyUserModel, UserModel } from "./user.model";
+export declare abstract class UserService {
+    static get(address: string): Promise<{
+        address: string;
+    } | null>;
+    static getMany(query: GetManyUserModel): Promise<{
+        address: string;
+        tags: string[];
+    }[]>;
+    static create(user: UserModel): Promise<{
+        address: string;
+        tags: string[];
+    }>;
+    static createMany(users: UserModel[]): Promise<import("../../../../database/api/.generated").Prisma.BatchPayload>;
+    static updateTags(user: string, tags: string[]): Promise<{
+        address: string;
+        tags: string[];
+    }>;
+}

package/dist/src/plugins/error-handling.plugin.d.ts

@@ -0,0 +1,28 @@
+import { BadRequestError, ConflictError, HttpError, NotFoundError, UnauthorizedError } from "../errors";
+import Elysia from "elysia";
+export declare const ErrorHandler: Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {
+        readonly HttpError: HttpError;
+        readonly BadRequestError: BadRequestError;
+        readonly ConflictError: ConflictError;
+        readonly NotFoundError: NotFoundError;
+        readonly UnauthorizedError: UnauthorizedError;
+    };
+}, {
+    schema: {};
+    macro: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/plugins/logger.plugin.d.ts

@@ -0,0 +1,21 @@
+import Elysia from "elysia";
+export declare const Logger: Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/routes/v1/allowances.d.ts

@@ -0,0 +1,66 @@
+import type { TokenInfoListType } from "../../libs/getTokensList";
+import { type UncachedResult } from "../../utils/execute";
+import type Elysia from "elysia";
+type ReturnType = {
+    [spender: string]: {
+        [address: string]: {
+            symbol: string;
+            allowance: string;
+            decimals: number;
+        };
+    };
+};
+export declare function getUserAllowances(user: string, spenders: string[], tokens: TokenInfoListType, chainId: number, additionalTokenAddresses?: string[]): Promise<UncachedResult<ReturnType>>;
+export declare const query: import("@sinclair/typebox").TObject<{
+    additionalTokenAddresses: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    chainId: import("@sinclair/typebox").TNumber;
+    user: import("@sinclair/typebox").TString;
+}>;
+export declare const response: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+    balance: import("@sinclair/typebox").TNumber;
+    decimals: import("@sinclair/typebox").TNumber;
+    symbol: import("@sinclair/typebox").TString;
+}>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    index: {
+        get: {
+            body: unknown;
+            params: Record<never, string>;
+            query: {
+                additionalTokenAddresses?: string[] | undefined;
+                chainId: number;
+                user: string;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    [address: string]: {
+                        symbol: string;
+                        balance: string;
+                        decimals: number;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;