@merkl/api 0.10.78

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

@@ -0,0 +1,21 @@
+import { type ChainId } from "@sdk";
+import type { RootByTimestampModel } from "./merklRoot.model";
+export declare class MerklRootRepository {
+    static firstRoot(chainId: ChainId): Promise<{
+        root: string;
+        chainId: number;
+        epoch: number;
+        timestamp: bigint;
+    } | null>;
+    static rootForTimestamp(x: RootByTimestampModel): Promise<{
+        root: string;
+        chainId: number;
+        epoch: number;
+        timestamp: bigint;
+    }[]>;
+    static fetch(chainId: ChainId): Promise<{
+        live: any;
+        tree: any;
+        lastTree: any;
+    }>;
+}

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

@@ -0,0 +1,34 @@
+import type { CacheKeys } from "../../../cache/keys";
+import type { ChainId } from "@sdk";
+import type { RootByTimestampModel } from "./merklRoot.model";
+export declare class MerklRootService {
+    static firstRoot(chainId: ChainId): Promise<{
+        root: string;
+        chainId: number;
+        epoch: number;
+        timestamp: bigint;
+    } | null>;
+    static rootForTimestamp(x: RootByTimestampModel): Promise<{
+        root: string;
+        chainId: number;
+        epoch: number;
+        timestamp: bigint;
+    }[]>;
+    /**
+     * Fetch roots for the provided chain
+     * @param chainId to fetch roots for
+     * @returns object with live and last tree roots
+     */
+    static fetch(chainId: ChainId): Promise<CacheKeys["CurrentRoot"]["returns"]>;
+    /**
+     * Fetch all roots for the provided chains
+     * @param chainIds to fetch roots for
+     * @returns record of chains to object with live and last tree roots
+     */
+    static fetchAll(chainIds?: ChainId[]): Promise<{
+        [chainId: number]: {
+            live: string;
+            lastTree: string;
+        };
+    }>;
+}

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

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

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

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

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

@@ -0,0 +1,113 @@
+import type { AprRecord } from "../apr/apr.model";
+import type { Resource } from "../prisma";
+import type { Protocol, ProtocolId } from "../protocol/protocol.model";
+import type { DailyRewardsRecord } from "../reward";
+import { type Token } from "../token/token.model";
+import type { TvlRecord } from "../tvl/tvl.model";
+import { CampaignType, OpportunityAction } from "../../../../database/api/.generated";
+import type { ChainId } from "@sdk";
+import type { Campaign } from "../campaign";
+import type { Chain } from "../chain/chain.model";
+import type { OpportunityRepository } from "./opportunity.repository";
+/**
+ * Opportunity
+ * @description Target description of rewards campaigns
+ * @see {@link Resource}
+ */
+export type Opportunity = Resource<"Opportunity", "mainProtocolId", {
+    chain: Chain["model"];
+    tokens: Token["model"][];
+    protocol?: Protocol["model"];
+    aprRecord?: AprRecord["model"];
+    tvlRecord?: TvlRecord["model"];
+    rewardsRecord?: DailyRewardsRecord["model"];
+    campaigns?: Campaign["model"][];
+}>;
+export type LightOpportunityFromDB = Omit<Awaited<ReturnType<typeof OpportunityRepository.findUniqueOrThrow>>, "AprRecords" | "TvlRecords" | "DailyRewardsRecords">;
+export type OpportunityMetadata = {
+    name: string;
+    action: OpportunityAction;
+    tokens: {
+        chainId: number;
+        address: string;
+    }[];
+    mainProtocol?: ProtocolId;
+};
+export type OpportunityUnique = {
+    chainId: ChainId;
+    type: CampaignType;
+    identifier: string;
+};
+export declare const OpportunityUniqueDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+}>;
+export declare const GetOpportunitiesQueryDto: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRegExp>;
+    action: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TEnum<{
+        POOL: "POOL";
+        HOLD: "HOLD";
+        DROP: "DROP";
+        LEND: "LEND";
+        BORROW: "BORROW";
+        INVALID: "INVALID";
+    }>, import("@sinclair/typebox").TRegExp]>>;
+    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TEnum<{
+        NONE: "NONE";
+        PAST: "PAST";
+        LIVE: "LIVE";
+        SOON: "SOON";
+    }>, import("@sinclair/typebox").TRegExp]>>;
+    sort: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"tvl" | "apr" | "rewards">[]>>;
+    order: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"asc" | "desc">[]>>;
+    mainProtocolId: import("@sinclair/typebox").TOptional<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 CreateOpportunityDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    type: import("@sinclair/typebox").TEnum<{
+        INVALID: "INVALID";
+        ERC20: "ERC20";
+        CLAMM: "CLAMM";
+        ERC20_SNAPSHOT: "ERC20_SNAPSHOT";
+        JSON_AIRDROP: "JSON_AIRDROP";
+        SILO: "SILO";
+        RADIANT: "RADIANT";
+        MORPHO: "MORPHO";
+        DOLOMITE: "DOLOMITE";
+        BADGER: "BADGER";
+        COMPOUND: "COMPOUND";
+        AJNA: "AJNA";
+        EULER: "EULER";
+        UNISWAP_V4: "UNISWAP_V4";
+    }>;
+    identifier: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    status: import("@sinclair/typebox").TEnum<{
+        NONE: "NONE";
+        PAST: "PAST";
+        LIVE: "LIVE";
+        SOON: "SOON";
+    }>;
+    action: import("@sinclair/typebox").TEnum<{
+        POOL: "POOL";
+        HOLD: "HOLD";
+        DROP: "DROP";
+        LEND: "LEND";
+        BORROW: "BORROW";
+        INVALID: "INVALID";
+    }>;
+    tokens: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        address: import("@sinclair/typebox").TString;
+        chainId: import("@sinclair/typebox").TNumber;
+    }>>;
+    protocols: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    mainProtocol: import("@sinclair/typebox").TString;
+}>;
+export type GetOpportunitiesQueryEntity = typeof GetOpportunitiesQueryDto.static;
+export type CreateOpportunityModel = typeof CreateOpportunityDto.static & {
+    id: string;
+};