@merkl/api 0.10.78

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

@@ -0,0 +1,169 @@
+import Elysia from "elysia";
+export declare const PriceController: Elysia<"/prices", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    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;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,32 @@
+export declare const CreatePriceSourceDto: import("@sinclair/typebox").TObject<{
+    symbol: import("@sinclair/typebox").TString;
+    method: import("@sinclair/typebox").TEnum<{
+        COINGECKO: "COINGECKO";
+        CONSTANT: "CONSTANT";
+        EQUAL_TO: "EQUAL_TO";
+        ERC4626: "ERC4626";
+        DEXSCREENER: "DEXSCREENER";
+        INDEXCOOP: "INDEXCOOP";
+        DEFILLAMA: "DEFILLAMA";
+    }>;
+    args: import("@sinclair/typebox").TObject<{}>;
+}>;
+export declare const UpdatePriceSourceDto: import("@sinclair/typebox").TObject<{
+    symbol: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    method: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<{
+        COINGECKO: "COINGECKO";
+        CONSTANT: "CONSTANT";
+        EQUAL_TO: "EQUAL_TO";
+        ERC4626: "ERC4626";
+        DEXSCREENER: "DEXSCREENER";
+        INDEXCOOP: "INDEXCOOP";
+        DEFILLAMA: "DEFILLAMA";
+    }>>;
+    args: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{}>>;
+}>;
+export declare const PriceSourceIdentifier: import("@sinclair/typebox").TObject<{
+    symbol: import("@sinclair/typebox").TString;
+}>;
+export type CreatePriceSourceModel = typeof CreatePriceSourceDto.static;
+export type PriceSourceIdentifierModel = typeof PriceSourceIdentifier.static;
+export type UpdatePriceSourceModel = typeof UpdatePriceSourceDto.static;

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

@@ -0,0 +1,33 @@
+import type { CreatePriceSourceModel, UpdatePriceSourceModel } from ".";
+export declare class PriceRepository {
+    static findBySymbolOrThrow(symbol: string): Promise<{
+        id: number;
+        symbol: string;
+        method: import("../../../../database/api/.generated").$Enums.PriceSourceMethod;
+        args: import("../../../../database/api/.generated").Prisma.JsonValue | null;
+    }>;
+    static findMany(): Promise<{
+        id: number;
+        symbol: string;
+        method: import("../../../../database/api/.generated").$Enums.PriceSourceMethod;
+        args: import("../../../../database/api/.generated").Prisma.JsonValue | null;
+    }[]>;
+    static create(priceSource: CreatePriceSourceModel): Promise<{
+        id: number;
+        symbol: string;
+        method: import("../../../../database/api/.generated").$Enums.PriceSourceMethod;
+        args: import("../../../../database/api/.generated").Prisma.JsonValue | null;
+    }>;
+    static updateBySymbol(unique: string, newPriceSource: UpdatePriceSourceModel): Promise<{
+        id: number;
+        symbol: string;
+        method: import("../../../../database/api/.generated").$Enums.PriceSourceMethod;
+        args: import("../../../../database/api/.generated").Prisma.JsonValue | null;
+    }>;
+    static deleteBySymbol(symbol: string): Promise<{
+        id: number;
+        symbol: string;
+        method: import("../../../../database/api/.generated").$Enums.PriceSourceMethod;
+        args: import("../../../../database/api/.generated").Prisma.JsonValue | null;
+    }>;
+}

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

@@ -0,0 +1,33 @@
+import type { CreatePriceSourceModel, UpdatePriceSourceModel } from ".";
+export declare class PriceService {
+    static findMany(): Promise<{
+        [token: string]: number;
+    }>;
+    /** Fetches a single price */
+    static fetchPriceSourceBySymbol(symbol: string): Promise<number>;
+    static getPriceSourceBySymbol(symbol: string): Promise<{
+        id: number;
+        symbol: string;
+        method: import("../../../../database/api/.generated").$Enums.PriceSourceMethod;
+        args: import("../../../../database/api/.generated").Prisma.JsonValue | null;
+    }>;
+    static getManyPriceSources(): Promise<{
+        id: number;
+        symbol: string;
+        method: import("../../../../database/api/.generated").$Enums.PriceSourceMethod;
+        args: import("../../../../database/api/.generated").Prisma.JsonValue | null;
+    }[]>;
+    static createPriceSource(priceSource: CreatePriceSourceModel): Promise<number>;
+    static updatePriceSource(symbol: string, newPriceSource: UpdatePriceSourceModel): Promise<{
+        id: number;
+        symbol: string;
+        method: import("../../../../database/api/.generated").$Enums.PriceSourceMethod;
+        args: import("../../../../database/api/.generated").Prisma.JsonValue | null;
+    }>;
+    static deletePriceSource(symbol: string): Promise<{
+        id: number;
+        symbol: string;
+        method: import("../../../../database/api/.generated").$Enums.PriceSourceMethod;
+        args: import("../../../../database/api/.generated").Prisma.JsonValue | null;
+    }>;
+}

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

@@ -0,0 +1,32 @@
+import type { Prisma as PrismaTypes } from "../../../../database/api/.generated";
+type Prisma = PrismaTypes.TypeMap["model"];
+type Model<R extends keyof Prisma> = Prisma[R]["payload"]["scalars"];
+type Operations<R extends keyof Prisma> = Prisma[R]["operations"];
+type OptionalKeys<Obj> = keyof {
+    [Key in keyof Obj as Omit<Obj, Key> extends Obj ? Key : never]: Obj[Key];
+};
+/**
+ * A resource from the prisma generated types
+ * @param Schema - name of the resource
+ * @typeParam DbSpecificKeys - keys to remove from default model
+ * @typeParam Override - addtional properties to add
+ * @returns A type with members for every prisma declaration
+ * @example type User = Resource<"User", "id">;
+ * const userTemplate: User["action"]["create"] = {...}
+ * const userUpsert: User["action"]["upsert"] = {...}
+ * const user: User["model"] = {...}
+ * const userDbRaw: User["raw"] = {...}
+ */
+export type Resource<Schema extends keyof Prisma, DbSpecificKeys extends keyof Model<Schema> | undefined = undefined, Override extends {} = {}> = {
+    model: {
+        [K in Exclude<keyof Model<Schema> | keyof Override, DbSpecificKeys | OptionalKeys<Override>>]: K extends keyof Override ? Override[K] : K extends DbSpecificKeys ? never : K extends keyof Model<Schema> ? Model<Schema>[K] : never;
+    } & {
+        [K in OptionalKeys<Override>]?: Override[K];
+    };
+    raw: Model<Schema>;
+} & {
+    action: {
+        [O in keyof Operations<Schema>]: Operations<Schema>[O];
+    };
+};
+export {};

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

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

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

@@ -0,0 +1,87 @@
+import Elysia from "elysia";
+export declare const ProtocolController: Elysia<"/protocols", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    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;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,27 @@
+import type { Resource } from "../prisma";
+/**
+ * Protocol
+ * @description Target description of rewards campaigns
+ * @see {@link Resource}
+ */
+export type Protocol = Resource<"Protocol", "id">;
+declare const protocolTypes: readonly ["arthswap", "baseswap", "camelot", "crust", "fenix", "horiza", "izumi", "kim", "pancakeswap-v3", "quickswap-algebra", "quickswap-uni", "ramses", "retro", "stryke", "stryke-pcs", "stryke-sushi", "sushiswap-v3", "swapr", "thruster", "uniswap-v3", "voltage", "zero", "koi", "supswap-v3", "uniswap-v2", "velodrome", "aerodrome", "balancer", "curve", "aura", "akron", "beefy", "dragonswap", "poolside", "koi", "radiant", "aave", "euler", "gearbox", "compound", "sturdy", "frax", "ionic", "moonwell", "fluid", "silo", "morpho", "coumpound", "dolomite", "badger", "ajna", "layerbank"];
+export type ProtocolId = (typeof protocolTypes)[number];
+export declare const GetProtocolsQueryDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TEnum<{
+        AMM: "AMM";
+        ALM: "ALM";
+        DEX: "DEX";
+        LENDING: "LENDING";
+    }>>>;
+    page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const GetProtocolParamsDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+}>;
+export type GetProtocolsQueryModel = typeof GetProtocolsQueryDto.static;
+export type GetProtocolModel = typeof GetProtocolParamsDto.static;
+export {};

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

@@ -0,0 +1,37 @@
+import type { GetProtocolsQueryModel, Protocol } from "./protocol.model";
+export declare abstract class ProtocolRepository {
+    #private;
+    static create(template: Protocol["action"]["create"]["args"]): Promise<{
+        id: string;
+        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+        name: string;
+        description: string;
+        url: string;
+        icon: string;
+    }>;
+    static read(type: string): Promise<{
+        id: string;
+        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+        name: string;
+        description: string;
+        url: string;
+        icon: string;
+    } | null>;
+    static findManyByName(name: string): Promise<{
+        id: string;
+        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+        name: string;
+        description: string;
+        url: string;
+        icon: string;
+    }[]>;
+    static findMany(query: GetProtocolsQueryModel): Promise<{
+        id: string;
+        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+        name: string;
+        description: string;
+        url: string;
+        icon: string;
+    }[]>;
+    static countMany(query: GetProtocolsQueryModel): Promise<number>;
+}

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

@@ -0,0 +1,10 @@
+import { AMM as AMMV3 } from "@sdk";
+import type { GetProtocolsQueryModel, Protocol, ProtocolId } from "./protocol.model";
+export declare abstract class ProtocolService {
+    static getIdFromAmmV3(amm: AMMV3): ProtocolId;
+    static getIdFromErc20Type(_type: string): ProtocolId | undefined;
+    static findMany(query: GetProtocolsQueryModel): Promise<Protocol["model"][] | null>;
+    static countMany(query: GetProtocolsQueryModel): Promise<number>;
+    static getFromId(id: ProtocolId | string): Promise<Protocol["model"] | null>;
+    static getFromName(name: string): Promise<Protocol["model"] | null>;
+}

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

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

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

@@ -0,0 +1,158 @@
+import Elysia from "elysia";
+export declare const RewardController: Elysia<"/rewards", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    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;
+                        };
+                    }[];
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;