@merkl/api 0.10.78

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

@@ -0,0 +1,413 @@
+import { type CreateCampaignModel } from "../campaign";
+import { type Status } from "../../../../database/api/.generated";
+import type { ChainId } from "@sdk";
+import type { CreateOpportunityModel, GetOpportunitiesQueryEntity, LightOpportunityFromDB, OpportunityMetadata, OpportunityUnique } from "./opportunity.model";
+import { OpportunityRepository } from "./opportunity.repository";
+export declare abstract class OpportunityService {
+    static hashId(opportunity: OpportunityUnique): string;
+    /**
+     * create an opportunity without campaigns
+     * @param newOpp the new opportunity to create
+     * @returns {Promise<Opportunity|undefined>}
+     */
+    static create(newOpp: Omit<CreateOpportunityModel, "id">): Promise<void>;
+    /**
+     * build/fetch metadata of a campaign's opportunity
+     * @param campaign
+     * @returns {OpportunityMetadata}
+     */
+    static getMetadata(campaign: CreateCampaignModel): Promise<OpportunityMetadata>;
+    static updateMetadata(chain: ChainId): Promise<void>;
+    static updateStatus(opportunityId: string, newStatus: Status): Promise<{
+        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[];
+    }>;
+    static getUniqueWithCampaignsOrThrow(opportunityId: string | OpportunityUnique): Promise<({
+        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;
+    } & {
+        campaigns: ({
+            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)[];
+    }) | null>;
+    static getUniqueOrThrow(opportunityId: string | OpportunityUnique): Promise<{
+        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>;
+    /**
+     * Get the list of opportunities satisfying the query
+     * @param query
+     * @returns A list of opportunities
+     */
+    static getMany(query: GetOpportunitiesQueryEntity): Promise<({
+        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)[]>;
+    static getAllIds(): Promise<{
+        id: string;
+    }[]>;
+    /**
+     * Counts the number of opportunities that complies to query
+     * @description used for pagination purposes
+     * @param query
+     * @returns the number of opportunities
+     */
+    static countMany(query: GetOpportunitiesQueryEntity): Promise<number>;
+    static formatResponse(opportunity: Awaited<ReturnType<typeof OpportunityRepository.findUniqueOrThrow>>): {
+        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;
+    static formatResponseBase(opportunity: LightOpportunityFromDB): {
+        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;
+    };
+}

package/dist/src/modules/v4/opportunity/subservices/getAjnaMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { AjnaCampaign, ChainId } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getAjnaMetadata: (chainId: ChainId, campaignSubType: AjnaCampaign["campaignSubType"], params: AjnaCampaign["campaignParameters"]) => Promise<OpportunityMetadata>;

package/dist/src/modules/v4/opportunity/subservices/getBadgerMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { BadgerCampaign, ChainId } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getBadgerMetadata: (chainId: ChainId, params: BadgerCampaign["campaignParameters"]) => Promise<OpportunityMetadata>;

package/dist/src/modules/v4/opportunity/subservices/getClammMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import { type CLAMMCampaign, ChainId } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getClammMetadata: (chainId: ChainId, params: CLAMMCampaign["campaignParameters"]) => OpportunityMetadata;

package/dist/src/modules/v4/opportunity/subservices/getCompoundMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import { type ChainId, type CompoundCampaign } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getCompoundMetadata: (chainId: ChainId, campaignSubType: CompoundCampaign["campaignSubType"], params: CompoundCampaign["campaignParameters"]) => OpportunityMetadata;

package/dist/src/modules/v4/opportunity/subservices/getDolomiteMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { ChainId, DolomiteCampaign } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getDolomiteMetadata: (chainId: ChainId, campaignSubType: DolomiteCampaign["campaignSubType"], params: DolomiteCampaign["campaignParameters"]) => OpportunityMetadata;

package/dist/src/modules/v4/opportunity/subservices/getErc20Metadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { OpportunityMetadata } from "..";
+import type { ChainId, ERC20Campaign } from "@sdk";
+export declare const getErc20Metadata: (chainId: ChainId, campaignId: string, rewardToken: string, amount: string, params: ERC20Campaign["campaignParameters"]) => Promise<OpportunityMetadata>;

package/dist/src/modules/v4/opportunity/subservices/getErc20SnapshotMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { ChainId, ERC20_SNAPSHOTCampaign } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getErc20SnapshotMetadata: (chainId: ChainId, params: ERC20_SNAPSHOTCampaign["campaignParameters"]) => OpportunityMetadata;

package/dist/src/modules/v4/opportunity/subservices/getEulerMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { ChainId, EulerCampaign } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getEulerMetadata: (chainId: ChainId, campaignId: string, campaignSubType: EulerCampaign["campaignSubType"], rewardToken: string, amount: string, params: EulerCampaign["campaignParameters"]) => Promise<OpportunityMetadata>;

package/dist/src/modules/v4/opportunity/subservices/getJsonAirDropMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { ChainId, JSON_AIRDROPCampaign } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getJsonAirdropMetadata: (chainId: ChainId, creator: string, params: JSON_AIRDROPCampaign["campaignParameters"]) => Promise<OpportunityMetadata>;

package/dist/src/modules/v4/opportunity/subservices/getMorphoMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { OpportunityMetadata } from "..";
+import { type ChainId, type MorphoCampaign, type MorphoSubCampaignType } from "@sdk";
+export declare const getMorphoMetadata: (chainId: ChainId, campaignSubType: MorphoCampaign<MorphoSubCampaignType>["campaignSubType"], params: MorphoCampaign<MorphoSubCampaignType>["campaignParameters"]) => OpportunityMetadata;

package/dist/src/modules/v4/opportunity/subservices/getRadiantMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { ChainId, RadiantCampaign } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getRadiantMetadata: (chainId: ChainId, campaignSubType: RadiantCampaign["campaignSubType"], params: RadiantCampaign["campaignParameters"]) => OpportunityMetadata;

package/dist/src/modules/v4/opportunity/subservices/getSiloMetadata.service.d.ts

@@ -0,0 +1,3 @@
+import type { ChainId, SILOCampaign } from "@sdk";
+import type { OpportunityMetadata } from "../opportunity.model";
+export declare const getSiloMetadata: (chainId: ChainId, campaignSubType: SILOCampaign["campaignSubType"], params: SILOCampaign["campaignParameters"]) => OpportunityMetadata;

package/dist/src/modules/v4/opportunity/transform-id.pipe.d.ts

@@ -0,0 +1,5 @@
+export declare function transformId({ params }: {
+    params: {
+        id: string;
+    };
+}): void;

package/dist/src/modules/v4/opportunity/validate-id.pipe.d.ts

@@ -0,0 +1,5 @@
+export declare const validateId: ({ params }: {
+    params: {
+        id: string;
+    };
+}) => void;

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

@@ -0,0 +1,120 @@
+import Elysia from "elysia";
+export declare const ParticipateController: Elysia<"/participate", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    participate: {
+        targets: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    identifier?: string | undefined;
+                    chainId: number;
+                    protocolId: string;
+                };
+                headers: unknown;
+                response: {
+                    200: import("./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;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,51 @@
+import type { Token } from "../token";
+export declare const participateInputTypes: readonly ["tokenAmount", "token"];
+export type ParticipateInputType = (typeof participateInputTypes)[number];
+export type ParticipateInput<T extends ParticipateInputType = ParticipateInputType> = {
+    tokenAmount: {
+        chain: number[];
+        address: string[];
+        amount: number[];
+    };
+    token: {
+        address: string;
+    };
+}[T];
+export declare const participateTypes: readonly ["link", "deposit", "withdraw"];
+export type ParticipateType = (typeof participateTypes)[number];
+export type ParticipateSchema<T extends ParticipateType> = {
+    link: {
+        link: string;
+    };
+    deposit: {
+        inputs: ParticipateInput[];
+    };
+    withdraw: {
+        d: string;
+    };
+}[T];
+export type ParticipateTarget = {
+    identifier: string;
+    name: string;
+    tokens: Token["model"][];
+};
+export type ParticipateSchemas = {
+    [T in ParticipateType]?: ParticipateSchema<T>;
+};
+export declare const GetParticipateTargetsQueryDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    protocolId: import("@sinclair/typebox").TString;
+    identifier: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const GetParticipateQuoteQueryDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    protocolId: import("@sinclair/typebox").TString;
+    identifier: import("@sinclair/typebox").TString;
+    userAddress: import("@sinclair/typebox").TString;
+    fromTokenAddress: import("@sinclair/typebox").TString;
+    fromAmount: import("@sinclair/typebox").TString;
+}>;
+export declare const GetParticipateProtocolsQueryDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export type GetParticipateProtocolsQuery = typeof GetParticipateProtocolsQueryDto.static;

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

@@ -0,0 +1,8 @@
+import { EnsoService } from "../enso/enso.service";
+import type { ProtocolId } from "../protocol";
+import type { ParticipateTarget } from "./participate.model";
+export declare abstract class ParticipateService {
+    static getTarget(chainId: number, protocolId: ProtocolId, identifier: string): Promise<ParticipateTarget[] | undefined>;
+    static getTargetsFromEnsoTokens(tokens: Awaited<ReturnType<typeof EnsoService.getTokens>>): Promise<ParticipateTarget[]>;
+    static getTargets(chainId: number, protocolId: ProtocolId): Promise<ParticipateTarget[] | undefined>;
+}

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

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