@merkl/api 0.10.209 → 0.10.211

package/dist/src/libs/campaigns/campaignTypes/EigenLayerDynamicData.js

@@ -0,0 +1,67 @@
+import { BN2Number, ChainInteractionService, EigenLayerStrategyInterface, EigenLayerStrategy__factory, YEAR, } from "@sdk";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+export async function EigenLayerDynamicData(_chainId, campaigns) {
+    const pricer = await Pricer.load();
+    const calls = [];
+    for (const campaign of campaigns) {
+        calls.push({
+            allowFailure: true,
+            callData: EigenLayerStrategyInterface.encodeFunctionData("totalShares"),
+            target: campaign.campaignParameters.strategy,
+        });
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                let i = 0;
+                const dynamicData = [];
+                for (const campaign of campaigns) {
+                    let totalSupplyShares;
+                    let totalSupplyStrategy;
+                    try {
+                        totalSupplyShares = EigenLayerStrategyInterface.decodeFunctionResult("totalShares", result[i++])[0];
+                    }
+                    catch {
+                        log.warn(`Error getting totalShares for campaign ${campaign.campaignId} and strategy ${campaign.campaignParameters.strategy}`);
+                        totalSupplyShares = 0.0000001;
+                    }
+                    try {
+                        totalSupplyStrategy = BN2Number(await EigenLayerStrategy__factory.connect(campaign.campaignParameters.strategy, ChainInteractionService(campaign.computeChainId).provider()).sharesToUnderlying(totalSupplyShares), campaign.campaignParameters.decimalsUnderlyingToken);
+                    }
+                    catch {
+                        log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and strategy ${campaign.campaignParameters.strategy}`);
+                        totalSupplyStrategy = 0.0000001;
+                    }
+                    const priceRewardToken = (await pricer.get({
+                        address: campaign.rewardToken,
+                        chainId: campaign.chainId,
+                        symbol: campaign.campaignParameters.symbolRewardToken,
+                    })) ?? 0;
+                    const priceTargetToken = (await pricer.get({
+                        address: campaign.campaignParameters.underlyingToken,
+                        chainId: campaign.computeChainId,
+                        symbol: campaign.campaignParameters.symbolUnderlyingToken,
+                    })) ?? 0;
+                    const tvl = totalSupplyStrategy * priceTargetToken;
+                    dynamicData.push({
+                        ...campaign,
+                        apr: (priceRewardToken *
+                            BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                            YEAR *
+                            100) /
+                            campaign.campaignParameters.duration /
+                            (totalSupplyStrategy * priceTargetToken),
+                        totalSupplyTargetToken: totalSupplyStrategy,
+                        tvl,
+                        priceRewardToken: priceRewardToken,
+                    });
+                }
+                return dynamicData;
+            },
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignsDynamicData.js

@@ -8,6 +8,7 @@ import { CompoundDynamicData } from "./campaignTypes/CompoundDynamicData";
 import { DolomiteDynamicData } from "./campaignTypes/DolomiteDynamicData";
 import { ERC20DynamicData } from "./campaignTypes/ERC20DynamicData";
 import { ERC20_SNAPSHOTDynamicData } from "./campaignTypes/ERC20_SNAPSHOTDynamicData";
+import { EigenLayerDynamicData } from "./campaignTypes/EigenLayerDynamicData";
 import { EulerDynamicData } from "./campaignTypes/EulerDynamicData";
 import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData";
 import { MORPHODynamicData } from "./campaignTypes/MORPHODynamicData";
@@ -61,6 +62,9 @@ export async function campaignsDynamicData(chainId, campaigns, type) {
         case Campaign.COMPOUND: {
             return CompoundDynamicData(chainId, campaigns);
         }
+        case Campaign.EIGENLAYER: {
+            return EigenLayerDynamicData(chainId, campaigns);
+        }
     }
     return {
         cached: false,

package/dist/src/libs/positions/EigenLayer/index.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+import type { EigenLayerFetchedCampaign, PositionType } from "../types";
+export declare function getEigenLayerUserPositions(user: string, _chainId: MerklChainId, campaigns: {
+    [mainparameter: string]: EigenLayerFetchedCampaign;
+}): Promise<UncachedResult<PositionType>>;

package/dist/src/libs/positions/EigenLayer/index.js

@@ -0,0 +1,53 @@
+import { BN2Number, ChainInteractionService, EigenLayerStrategyInterface, EigenLayerStrategy__factory, } from "@sdk";
+export async function getEigenLayerUserPositions(user, _chainId, campaigns) {
+    /**
+     * Fetch user positions
+     */
+    const calls = [];
+    for (const mainParameter of Object.keys(campaigns)) {
+        calls.push({
+            allowFailure: true,
+            callData: EigenLayerStrategyInterface.encodeFunctionData("shares", [user]),
+            target: campaigns[mainParameter].strategy,
+        });
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                let j = 0;
+                const finalRes = {};
+                for (const campaignId of Object.keys(campaigns)) {
+                    let userShares = 0;
+                    let userSupply = 0;
+                    const strategy = campaigns[campaignId].strategy;
+                    userShares = EigenLayerStrategyInterface.decodeFunctionResult("shares", result[j++])[0];
+                    userSupply = BN2Number(await EigenLayerStrategy__factory.connect(strategy, ChainInteractionService(_chainId).provider()).sharesToUnderlying(userShares), campaigns[campaignId].decimals);
+                    const res = {
+                        userPositions: [],
+                        decimals: campaigns[campaignId].decimals,
+                        totalSupply: BN2Number(campaigns[campaignId].totalSupplyTargetToken, campaigns[campaignId].decimals),
+                        userTVL: 0,
+                    };
+                    if (userSupply > 0) {
+                        res.userPositions.push({
+                            balance: userSupply,
+                            token: strategy,
+                            origin: "Direct",
+                            totalSupply: campaigns.campaignId.totalSupplyTargetToken,
+                            tvl: campaigns[campaignId].tvl,
+                        });
+                        // to modify
+                    }
+                    // Add to final result if there are positions
+                    if (res.userPositions.length > 0) {
+                        finalRes[`14_${campaignId}`] = { ...res };
+                    }
+                }
+                return finalRes;
+            },
+        },
+    };
+}

package/dist/src/libs/positions/ajna/index.d.ts

@@ -1,41 +1,6 @@
-import { type Forwarder, type ForwarderParameters, type MerklChainId } from "@sdk";
+import { type MerklChainId } from "@sdk";
 import type { UncachedResult } from "../../../utils/execute";
-export type UserPosition = {
-    balance: number;
-    token: string;
-    origin: string;
-    totalSupply: number;
-    tvl: number;
-};
-export type FetchedCampaign = {
-    rewardToken: string;
-    targetToken: string;
-    symbolRewardToken: string;
-    subtype: number;
-    tvl: number;
-    poolId: string;
-    decimals: number;
-    totalSupplyTargetToken: number;
-    computedtotalSupply: number;
-    amount: number;
-    forwarders?: {
-        [address: string]: ForwarderParameters<Forwarder>;
-    };
-};
-export type MorphoPositionType = {
-    [mainParameter: string]: {
-        userPositions: UserPosition[];
-        decimals: number;
-        totalSupply: number;
-        userTVL: number;
-    };
-};
-export type Res = {
-    userPositions: UserPosition[];
-    decimals: number;
-    totalSupply: number;
-    userTVL: number;
-};
+import type { AjnaFetchedCampaign, PositionType } from "../types";
 export declare function getAjnaUserPositions(user: string, _chainId: MerklChainId, campaigns: {
-    [mainparameter: string]: FetchedCampaign;
-}): Promise<UncachedResult<MorphoPositionType>>;
+    [mainparameter: string]: AjnaFetchedCampaign;
+}): Promise<UncachedResult<PositionType>>;

package/dist/src/libs/positions/ajna/index.js

@@ -1,5 +1,5 @@
 import { batchMulticallCallWithRetry } from "../../../utils/generic";
-import { AjnaSubCampaignType, BN2Number, NETWORK_LABELS, PoolInfoUtilsInterface, } from "@sdk";
+import { AjnaSubCampaignType, BN2Number, NETWORK_LABELS, PoolInfoUtilsInterface } from "@sdk";
 import { POOL_INFO_UTILS } from "@sdk";
 import axios from "axios";
 export async function getAjnaUserPositions(user, _chainId, campaigns) {
@@ -28,7 +28,7 @@ export async function getAjnaUserPositions(user, _chainId, campaigns) {
         call: {
             callData: calls,
             handler: () => { },
-            reducer: async (result) => {
+            reducer: async (_result) => {
                 const finalRes = {};
                 const resCalls = await batchMulticallCallWithRetry(_chainId, {
                     calls,

package/dist/src/libs/positions/badger/index.d.ts

@@ -1,27 +1,6 @@
 import { type MerklChainId } from "@sdk";
 import type { UncachedResult } from "../../../utils/execute";
-import type { FetchedCampaign } from "../morpho";
-export type UserPosition = {
-    balance: number;
-    token: string;
-    origin: string;
-    totalSupply: number;
-    tvl: number;
-};
-export type MorphoPositionType = {
-    [mainParameter: string]: {
-        userPositions: UserPosition[];
-        decimals: number;
-        totalSupply: number;
-        userTVL: number;
-    };
-};
-export type Res = {
-    userPositions: UserPosition[];
-    decimals: number;
-    totalSupply: number;
-    userTVL: number;
-};
+import type { BadgerFetchedCampaign, PositionType } from "../types";
 export declare function getBadgerUserPositions(user: string, _chainId: MerklChainId, campaigns: {
-    [mainparameter: string]: FetchedCampaign;
-}): Promise<UncachedResult<MorphoPositionType>>;
+    [mainparameter: string]: BadgerFetchedCampaign;
+}): Promise<UncachedResult<PositionType>>;

package/dist/src/libs/positions/badger/index.js

@@ -70,7 +70,7 @@ export async function getBadgerUserPositions(user, _chainId, campaigns) {
                     if (res.userPositions.length > 0) {
                         finalRes[`9_${campaignId}`] = { ...res };
                     }
-                    i++;
+                    i = i++;
                 }
                 return finalRes;
             },

package/dist/src/libs/positions/index.js

@@ -1,6 +1,7 @@
 import { Campaign, withTimeout } from "@sdk";
 import { MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT } from "../../constants";
 import { executeSimple } from "../../utils/execute";
+import { getEigenLayerUserPositions } from "./EigenLayer";
 import { getAjnaUserPositions } from "./ajna";
 import { getBadgerUserPositions } from "./badger";
 import { getClammUserPositions } from "./clamm";
@@ -42,6 +43,9 @@ chainId, user) {
                 break;
             case Campaign.COMPOUND:
                 promises.push(withTimeout(executeSimple(chainId, getCompoundUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
+                break;
+            case Campaign.EIGENLAYER:
+                promises.push(withTimeout(executeSimple(chainId, getEigenLayerUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
         }
     }
     return Object.assign({}, ...(await Promise.all(promises)));

package/dist/src/libs/positions/morpho/index.d.ts

@@ -1,40 +1,6 @@
-import { type Forwarder, type ForwarderParameters, type MerklChainId } from "@sdk";
+import { type MerklChainId } from "@sdk";
 import type { UncachedResult } from "../../../utils/execute";
-export type MorphoPositionType = {
-    [mainParameter: string]: {
-        userPositions: UserPosition[];
-        decimals: number;
-        totalSupply: number;
-        userTVL: number;
-    };
-};
-export type FetchedCampaign = {
-    rewardToken: string;
-    targetToken: string;
-    symbolRewardToken: string;
-    subtype: number;
-    tvl: number;
-    marketId: string;
-    decimals: number;
-    totalSupplyTargetToken: number;
-    amount: number;
-    forwarders?: {
-        [address: string]: ForwarderParameters<Forwarder>;
-    };
-};
-export type UserPosition = {
-    balance: number;
-    token: string;
-    origin: string;
-    totalSupply: number;
-    tvl: number;
-};
-export type Res = {
-    userPositions: UserPosition[];
-    decimals: number;
-    totalSupply: number;
-    userTVL: number;
-};
+import type { MorphoFetchedCampaign, PositionType } from "../types";
 export declare function getMorphoUserPositions(user: string, _chainId: MerklChainId, campaigns: {
-    [mainparameter: string]: FetchedCampaign;
-}): Promise<UncachedResult<MorphoPositionType>>;
+    [mainparameter: string]: MorphoFetchedCampaign;
+}): Promise<UncachedResult<PositionType>>;

package/dist/src/libs/positions/prepareFetch.js

@@ -312,8 +312,34 @@ function prepareCompoundFetch(previous, campaign) {
     };
     return previous;
 }
+function prepareEigenLayerFetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.EIGENLAYER) {
+        return previous;
+    }
+    const forwarders = {};
+    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
+        for (const forwarder of campaign.campaignParameters.forwarders) {
+            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
+        }
+    }
+    previous[campaign.mainParameter] = {
+        rewardToken: campaign.rewardToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        tvl: campaign.tvl,
+        forwarders: forwarders,
+        targetToken: campaign.campaignParameters.strategy,
+        decimalsTargetToken: campaign.campaignParameters.decimalsUnderlyingToken,
+        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
+        underlyingToken: campaign.campaignParameters.underlyingToken,
+        symbolUnderlyingToken: campaign.campaignParameters.symbolUnderlyingToken,
+        decimals: campaign.campaignParameters.decimalsUnderlyingToken,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+    };
+    return previous;
+}
 export function prepareFetch(type, previous, // FIXME
-campaign) {
+campaign //FIXME
+) {
     switch (type) {
         case Campaign.CLAMM:
             return prepareClammFetch(previous, campaign);
@@ -333,6 +359,8 @@ campaign) {
             return prepareAjnaFetch(previous, campaign);
         case Campaign.COMPOUND:
             return prepareCompoundFetch(previous, campaign);
+        case Campaign.EIGENLAYER:
+            return prepareEigenLayerFetch(previous, campaign);
         default:
             return previous;
     }

package/dist/src/libs/positions/types.d.ts

@@ -1,3 +1,42 @@
+import type { Forwarder, ForwarderParameters } from "@sdk";
+export interface BucketData {
+    bucket_index: number;
+    deposit: string;
+    bucket_price: string;
+}
+export type UserPosition = {
+    balance: number;
+    token: string;
+    origin: string;
+    totalSupply: number;
+    tvl: number;
+};
+export type PositionType = {
+    [mainParameter: string]: {
+        userPositions: UserPosition[];
+        decimals: number;
+        totalSupply: number;
+        userTVL: number;
+    };
+};
+export type FetchedCampaign = {
+    computedtotalSupply: number;
+    rewardToken: string;
+    symbolRewardToken: string;
+    tvl: number;
+    decimals: number;
+    totalSupplyTargetToken: number;
+    amount: number;
+    forwarders?: {
+        [address: string]: ForwarderParameters<Forwarder>;
+    };
+};
+export type Res = {
+    userPositions: UserPosition[];
+    decimals: number;
+    totalSupply: number;
+    userTVL: number;
+};
 export type CLAMMPosition = {
     userPositions: {
         almAddress: string;
@@ -18,3 +57,19 @@ export type CLAMMPosition = {
     userTotalLiquidity: number;
     userInRangeLiquidity: number;
 };
+export type AjnaFetchedCampaign = FetchedCampaign & {
+    subtype: number;
+    poolId: string;
+    quoteToken: string;
+};
+export type BadgerFetchedCampaign = FetchedCampaign & {
+    targetToken: string;
+};
+export type MorphoFetchedCampaign = FetchedCampaign & {
+    targetToken: string;
+    subtype: number;
+    marketId?: string;
+};
+export type EigenLayerFetchedCampaign = FetchedCampaign & {
+    strategy: string;
+};

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

@@ -60,7 +60,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 body: unknown;
                 params: {};
                 query: {
-                    type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
+                    type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER" | undefined;
                     items?: number | undefined;
                     subType?: number | undefined;
                     page?: number | undefined;
@@ -132,7 +132,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 body: unknown;
                 params: {};
                 query: {
-                    type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | undefined;
+                    type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER" | undefined;
                     items?: number | undefined;
                     subType?: number | undefined;
                     page?: number | undefined;

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

@@ -33,6 +33,8 @@ export declare const campaignTypeToEnumMap: {
     readonly SILO: any;
     readonly JSON_AIRDROP: any;
     readonly UNISWAP_V4: any;
+    readonly EIGENLAYER: any;
+    readonly ION: any;
 };
 export type ConvertedCampaignType<C extends CampaignType> = (typeof campaignTypeToEnumMap)[C];
 export declare const CampaignUniqueDto: import("@sinclair/typebox").TObject<{
@@ -117,6 +119,8 @@ export declare const GetCampaignQueryDto: import("@sinclair/typebox").TObject<{
         AJNA: "AJNA";
         EULER: "EULER";
         UNISWAP_V4: "UNISWAP_V4";
+        ION: "ION";
+        EIGENLAYER: "EIGENLAYER";
     }>>;
     subType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     campaignId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;

package/dist/src/modules/v4/campaign/campaign.model.js

@@ -20,6 +20,8 @@ export const campaignTypeToEnumMap = {
     SILO: CampaignTypeEnum.SILO,
     JSON_AIRDROP: CampaignTypeEnum.JSON_AIRDROP,
     UNISWAP_V4: CampaignTypeEnum.UNISWAP_V4,
+    EIGENLAYER: CampaignTypeEnum.EIGENLAYER,
+    ION: CampaignTypeEnum.ION,
 };
 // ─── DTOs ────────────────────────────────────────────────────────────────────
 export const CampaignUniqueDto = t.Object({

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

@@ -31,6 +31,7 @@ export declare const DynamicDataController: Elysia<"/dynamic-data", false, {
                         cardName: string;
                         blacklistedSupply: number;
                         priceTargetToken: number;
+                        type: string;
                     };
                 };
             };

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

@@ -5,6 +5,7 @@ type output = {
     cardName: string;
     blacklistedSupply: number;
     priceTargetToken: number;
+    type: string;
 };
 export declare class DynamicDataService {
     /** Fetches a single price */

package/dist/src/modules/v4/dynamicData/dynamicData.service.js

@@ -44,6 +44,7 @@ export class DynamicDataService {
             blacklistedSupply: result[0]?.typeInfo.blacklistedSupply,
             cardName: result[0]?.typeInfo.cardName,
             tvl: result[0]?.typeInfo.tvl,
+            type: result[0]?.type ?? "defaultType",
         };
     }
 }

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

@@ -17,7 +17,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
             post: {
                 body: {
                     name?: string | undefined;
-                    type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4";
+                    type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER";
                     tokens: {
                         chainId: number;
                         address: string;

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

@@ -315,6 +315,8 @@ export declare const CreateOpportunityDto: import("@sinclair/typebox").TObject<{
         AJNA: "AJNA";
         EULER: "EULER";
         UNISWAP_V4: "UNISWAP_V4";
+        ION: "ION";
+        EIGENLAYER: "EIGENLAYER";
     }>;
     identifier: import("@sinclair/typebox").TString;
     name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;

package/dist/src/modules/v4/opportunity/opportunity.service.js

@@ -12,6 +12,7 @@ import { getBadgerMetadata } from "./subservices/getBadgerMetadata.service";
 import { getClammMetadata } from "./subservices/getClammMetadata.service";
 import { getCompoundMetadata } from "./subservices/getCompoundMetadata.service";
 import { getDolomiteMetadata } from "./subservices/getDolomiteMetadata.service";
+import { getEigenLayerMetadata } from "./subservices/getEigenLayerMetadata.service";
 import { getErc20Metadata } from "./subservices/getErc20Metadata.service";
 import { getErc20SnapshotMetadata } from "./subservices/getErc20SnapshotMetadata.service";
 import { getEulerMetadata } from "./subservices/getEulerMetadata.service";
@@ -64,6 +65,8 @@ export class OpportunityService {
                 return getCompoundMetadata(chainId, campaign.subType, campaignParams);
             case "AJNA":
                 return getAjnaMetadata(chainId, campaign.subType, campaignParams);
+            case "EIGENLAYER":
+                return getEigenLayerMetadata(chainId, campaignParams);
             case "EULER":
                 return getEulerMetadata(chainId, campaign.campaignId, campaign.subType, campaign.rewardTokenAddress, campaign.amount, campaignParams);
             case "INVALID":

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

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

package/dist/src/modules/v4/opportunity/subservices/getEigenLayerMetadata.service.js

@@ -0,0 +1,9 @@
+import { OpportunityAction } from "../../../../../database/api/.generated";
+export const getEigenLayerMetadata = async (chainId, params) => {
+    return {
+        action: OpportunityAction.LEND,
+        name: ["EigenLayer", "strategy for", params.symbolUnderlyingToken].join(" "),
+        tokens: [{ chainId, address: params.underlyingToken }],
+        mainProtocol: "eigenlayer",
+    };
+};

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

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

package/dist/src/modules/v4/programPayload/index.js

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

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

@@ -0,0 +1,93 @@
+import Elysia from "elysia";
+export declare const ProgramPayloadController: Elysia<"/program-payload", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    "program-payload": {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    creator: string;
+                    startTimestamp: number;
+                    endTimestamp: number;
+                    campaign: string;
+                    distributionChainId: number;
+                    amount: string;
+                    rewardToken: string;
+                    program: string;
+                };
+                headers: unknown;
+                response: {
+                    [x: string]: any;
+                    200: any;
+                };
+            };
+        };
+    };
+} & {
+    "program-payload": {
+        config: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    creator: string;
+                    startTimestamp: number;
+                    endTimestamp: number;
+                    campaign: string;
+                    distributionChainId: number;
+                    amount: string;
+                    rewardToken: string;
+                    program: string;
+                };
+                headers: unknown;
+                response: {
+                    [x: string]: any;
+                    200: any;
+                };
+            };
+        };
+    };
+} & {
+    "program-payload": {
+        program: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    creator: string;
+                    startTimestamp: number;
+                    endTimestamp: number;
+                    distributionChainId: number;
+                    amount: string;
+                    rewardToken: string;
+                    program: string;
+                };
+                headers: unknown;
+                response: {
+                    [x: string]: any;
+                    200: any;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;