@merkl/api 0.10.168 → 0.10.169

package/dist/src/libs/positions/clamm/thegraph/fetchAlmPositions.d.ts

@@ -1,5 +1,5 @@
 import { type MerklChainId } from "@sdk";
 import { BigNumber } from "ethers";
-export declare function fetchAlmPositionsV2(chainId: MerklChainId, user: string): Promise<{
+export declare function fetchAlmPositions(chainId: MerklChainId, user: string): Promise<{
     [token: string]: BigNumber;
 }>;

package/dist/src/libs/positions/clamm/thegraph/fetchAlmPositions.js

@@ -4,7 +4,7 @@ import { request } from "graphql-request";
 import { almBalancesQuery, almNFTBalancesQuery } from ".";
 import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "../../../../constants";
 import { log } from "../../../../utils/logger";
-export async function fetchAlmPositionsV2(chainId, user) {
+export async function fetchAlmPositions(chainId, user) {
     const res = {};
     const availableALMEndpoints = merklSubgraphALMEndpoints[chainId];
     if (Object.keys(availableALMEndpoints).length > 0) {

package/dist/src/libs/positions/clamm/thegraph/fetchAmmPositions.d.ts

@@ -1,6 +1,6 @@
 import { AMM, type ANGLE_NETWORKS } from "@sdk";
 import { type PositionType } from ".";
-export declare function fetchAmmPositionsV2(chainId: (typeof ANGLE_NETWORKS.merkl)[number], user: string, amms: AMM[]): Promise<{
+export declare function fetchAmmPositions(chainId: (typeof ANGLE_NETWORKS.merkl)[number], user: string, amms: AMM[]): Promise<{
     [amm in AMM]?: {
         nft: PositionType[];
         direct: PositionType[];

package/dist/src/libs/positions/clamm/thegraph/fetchAmmPositions.js

@@ -3,7 +3,7 @@ import { request } from "graphql-request";
 import { positionsQuery } from ".";
 import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "../../../../constants";
 import { log } from "../../../../utils/logger";
-export async function fetchAmmPositionsV2(chainId, user, amms) {
+export async function fetchAmmPositions(chainId, user, amms) {
     const res = {};
     const promises = amms.map(async (amm) => {
         const tgURL = merklSubgraphAMMEndpoints[chainId][amm];
@@ -12,7 +12,7 @@ export async function fetchAmmPositionsV2(chainId, user, amms) {
                 owner: user?.toLowerCase(),
             }), MERKL_USER_POSITION_FETCHING_TIMEOUT)
                 .then(fetchedData => {
-                res[amm] = {};
+                res[amm] = { nft: [], direct: [] };
                 res[amm].nft = fetchedData?.nft?.reduce((prev, curr) => {
                     if (!prev.map(i => i.id).includes(curr.id))
                         prev.push(curr);

package/dist/src/libs/positions/clamm/thegraph/fetchFarmedPositions.d.ts

@@ -7,5 +7,4 @@ export type FarmPositionsType = {
         holder: string;
     }[];
 };
-export declare function fetchFarmedPositionsV2(chainId: MerklChainId, owners: string[], amm: AMM): Promise<FarmPositionsType>;
-export declare const fetchFarmedPositionsV2WithCache: (chainId: MerklChainId, user: string[], amm: AMM) => Promise<any>;
+export declare function fetchFarmedPositions(chainId: MerklChainId, owners: string[], amm: AMM): Promise<FarmPositionsType>;

package/dist/src/libs/positions/clamm/thegraph/fetchFarmedPositions.js

@@ -1,11 +1,9 @@
-import { Redis } from "../../../../cache";
 import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "../../../../constants";
-import { hashArray } from "../../../../utils/hashArray";
 import { AMM, NETWORK_LABELS, getSupportedNFPWrapperMapping, merklSubgraphNFPWrapperEndpoints, withTimeout, } from "@sdk";
 import { request } from "graphql-request";
 import { nftWrapperPositionsQuery } from ".";
 import { log } from "../../../../utils/logger";
-export async function fetchFarmedPositionsV2(chainId, owners, amm) {
+export async function fetchFarmedPositions(chainId, owners, amm) {
     const res = {};
     const promises = getSupportedNFPWrapperMapping(chainId, amm).map(async (wrapper) => {
         const tgURL = merklSubgraphNFPWrapperEndpoints[chainId][wrapper];
@@ -41,4 +39,3 @@ export async function fetchFarmedPositionsV2(chainId, owners, amm) {
     await Promise.all(promises);
     return res;
 }
-export const fetchFarmedPositionsV2WithCache = async (chainId, user, amm) => await Redis.getOrSet(`FarmedPositions_${hashArray(chainId, user, amm)}$`, fetchFarmedPositionsV2, chainId, user, amm);

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

@@ -1,6 +1,5 @@
-import { BN2Number, Campaign, ERC20Interface, EulerVault__factory } from "@sdk";
+import { BN2Number, Campaign, ERC20Interface } from "@sdk";
 import { getAddress } from "ethers/lib/utils";
-const EulerVaultInterface = EulerVault__factory.createInterface();
 export async function getEulerUserPositions(user, _chainId, tokens) {
     /**
      * Fetch user positions
@@ -9,7 +8,7 @@ export async function getEulerUserPositions(user, _chainId, tokens) {
     for (const token of Object.keys(tokens)) {
         calls.push({
             allowFailure: true,
-            callData: EulerVaultInterface.encodeFunctionData("balanceOf", [user]),
+            callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
             target: token,
         });
     }

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

@@ -17,7 +17,7 @@ chainId, user) {
         const numkey = Number(key);
         switch (numkey) {
             case Campaign.CLAMM:
-                promises.push(withTimeout(executeSimple(chainId, getClammUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
+                promises.push(withTimeout(getClammUserPositions(user, chainId, positionsToCheck[numkey]), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
                 break;
             case Campaign.ERC20:
                 promises.push(withTimeout(executeSimple(chainId, getERC20UserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));

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

@@ -75,7 +75,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 };
                 headers: unknown;
                 response: {
-                    200: ({
+                    200: {
                         params: any;
                         chain: {
                             name: string;
@@ -118,7 +118,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                         amount: string;
                         opportunityId: string;
                         creatorAddress: string;
-                    } | null)[];
+                    }[];
                 };
             };
         };

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

@@ -1,4 +1,4 @@
-import { type CampaignUnique, type ConvertedCampaignType, type CreateCampaignModel, type GetCampaignQueryModel } from "./";
+import { type Campaign, type CampaignUnique, type ConvertedCampaignType, type CreateCampaignModel, type GetCampaignQueryModel } from "./";
 import { CampaignRepository } from "./campaign.repository";
 import type { CampaignType } from "../../../../database/api/.generated";
 import { type CampaignParameters, type Campaign as CampaignTypeV3, type ChainId } from "@sdk";
@@ -28,7 +28,7 @@ export declare abstract class CampaignService {
      * @param query
      * @returns A list of campaigns
      */
-    static findMany(query: GetCampaignQueryModel): Promise<({
+    static findMany(query: GetCampaignQueryModel): Promise<{
         params: any;
         chain: {
             name: string;
@@ -71,7 +71,7 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
-    } | null)[]>;
+    }[]>;
     /**
      * Counts the number of campaigns that complies to query
      * @description used for pagination purposes
@@ -160,7 +160,7 @@ export declare abstract class CampaignService {
      * @returns A list of opportunities
      * TODO: remove this function in favor of prisma client extensions
      */
-    static format(campaign: NonNullable<Awaited<ReturnType<typeof CampaignRepository.findMany>>>[number] | null): {
+    static format(campaign: NonNullable<Awaited<ReturnType<typeof CampaignRepository.findMany>>>[number]): {
         params: any;
         chain: {
             name: string;
@@ -203,7 +203,8 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
-    } | null;
+    };
+    static formatAsCampaignParameters<C extends CampaignTypeV3>(campaign: Campaign["model"]): CampaignParameters<C>;
     /**
      * Fetches the campaign dynamic data for a v3 campaign onchain
      * @param chainId

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

@@ -164,8 +164,6 @@ export class CampaignService {
      * TODO: remove this function in favor of prisma client extensions
      */
     static format(campaign) {
-        if (campaign === null)
-            return null;
         const { DistributionChain, ComputeChain, RewardToken, params, CampaignStatus, ...c } = campaign;
         return {
             ...c,
@@ -177,6 +175,16 @@ export class CampaignService {
             campaignStatus: CampaignStatus?.[0],
         };
     }
+    static formatAsCampaignParameters(campaign) {
+        return {
+            campaignSubType: campaign.subType ?? 0,
+            campaignParameters: campaign.params,
+            computeChainId: campaign.computeChainId,
+            campaignId: campaign.campaignId,
+            rewardToken: campaign.rewardToken.address,
+            amount: campaign.amount,
+        };
+    }
     /**
      * Fetches the campaign dynamic data for a v3 campaign onchain
      * @param chainId

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

@@ -232,7 +232,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                             tvl: number;
                             apr: number;
                             dailyRewards: number;
-                            campaigns: ({
+                            campaigns: {
                                 params: any;
                                 chain: {
                                     name: string;
@@ -275,7 +275,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                                 amount: string;
                                 opportunityId: string;
                                 creatorAddress: string;
-                            } | null)[];
+                            }[];
                         } | null | undefined;
                     };
                 };

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

@@ -1,4 +1,5 @@
 import { type Prisma, Status } from "../../../../database/api/.generated";
+import type { MerklChainId } from "@sdk";
 import { type AprRecord } from "../apr";
 import { type DailyRewardsRecord } from "../reward";
 import { type TvlRecord } from "../tvl";
@@ -432,6 +433,164 @@ export declare abstract class OpportunityRepository {
         apr: number;
         dailyRewards: number;
     })[]>;
+    static findLiveWithFirstCampaign(chainId: MerklChainId): Promise<({
+        Chain: {
+            name: string;
+            id: number;
+            icon: string;
+        };
+        Campaigns: ({
+            ComputeChain: {
+                name: string;
+                id: number;
+                icon: string;
+            };
+            DistributionChain: {
+                name: string;
+                id: number;
+                icon: string;
+            };
+            RewardToken: {
+                symbol: string;
+                name: string | null;
+                id: string;
+                chainId: number;
+                address: string;
+                icon: string;
+                decimals: number;
+                verified: boolean;
+                price: number | null;
+            };
+            CampaignStatus: {
+                error: string;
+                details: Prisma.JsonValue;
+                status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                campaignId: string;
+                computedUntil: bigint;
+                processingStarted: bigint;
+            }[];
+        } & {
+            type: import("../../../../database/api/.generated").$Enums.CampaignType;
+            id: string;
+            params: Prisma.JsonValue;
+            subType: number | null;
+            startTimestamp: bigint;
+            endTimestamp: bigint;
+            computeChainId: number;
+            distributionChainId: number;
+            campaignId: string;
+            rewardTokenId: string;
+            amount: string;
+            opportunityId: string;
+            creatorAddress: string;
+        })[];
+        Tokens: {
+            symbol: string;
+            name: string | null;
+            id: string;
+            chainId: number;
+            address: string;
+            icon: string;
+            decimals: number;
+            verified: boolean;
+            price: number | null;
+        }[];
+        Protocols: {
+            name: string;
+            url: string;
+            description: string;
+            id: string;
+            tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+            icon: string;
+        }[];
+        MainProtocol: {
+            name: string;
+            url: string;
+            description: string;
+            id: string;
+            tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+            icon: string;
+        } | null;
+        TvlRecords: ({
+            TvlBreakdown: {
+                type: import("../../../../database/api/.generated").$Enums.TvlType;
+                id: number;
+                identifier: string;
+                value: number;
+                tvlRecordId: string;
+            }[];
+        } & {
+            total: number;
+            id: string;
+            timestamp: bigint;
+            opportunityId: string;
+        })[];
+        AprRecords: ({
+            AprBreakdown: {
+                type: import("../../../../database/api/.generated").$Enums.AprType;
+                id: number;
+                identifier: string;
+                value: number;
+                aprRecordId: string;
+            }[];
+        } & {
+            id: string;
+            timestamp: bigint;
+            opportunityId: string;
+            cumulated: number;
+        })[];
+        DailyRewardsRecords: ({
+            DailyRewardsBreakdown: ({
+                Campaign: {
+                    startTimestamp: bigint;
+                    endTimestamp: bigint;
+                    amount: string;
+                    RewardToken: {
+                        symbol: string;
+                        name: string | null;
+                        id: string;
+                        chainId: number;
+                        address: string;
+                        icon: string;
+                        decimals: number;
+                        verified: boolean;
+                        price: number | null;
+                    };
+                    CampaignStatus: {
+                        error: string;
+                        details: Prisma.JsonValue;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[];
+                };
+            } & {
+                id: number;
+                value: number;
+                campaignId: string;
+                dailyRewardsRecordId: string;
+            })[];
+        } & {
+            total: number;
+            id: string;
+            timestamp: bigint;
+            opportunityId: string;
+        })[];
+    } & {
+        name: string;
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        id: string;
+        status: import("../../../../database/api/.generated").$Enums.Status;
+        tags: string[];
+        identifier: string;
+        chainId: number;
+        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        mainProtocolId: string | null;
+        tvl: number;
+        apr: number;
+        dailyRewards: number;
+    })[]>;
     static countMany(query: GetOpportunitiesQueryEntity): Promise<number>;
     static getAllIdsForDynamicOpp(): Promise<{
         id: string;

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

@@ -1,5 +1,6 @@
 import { apiDbClient } from "../../../utils/prisma";
 import { Status } from "../../../../database/api/.generated";
+import moment from "moment";
 import { AprService } from "../apr";
 import { RewardService } from "../reward";
 import { TvlService } from "../tvl";
@@ -176,6 +177,34 @@ export class OpportunityRepository {
             ...args,
         });
     }
+    static async findLiveWithFirstCampaign(chainId) {
+        const now = moment().unix();
+        return await apiDbClient.opportunity.findMany({
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(),
+                Campaigns: {
+                    include: { RewardToken: true, ComputeChain: true, DistributionChain: true, CampaignStatus: true },
+                    take: 1,
+                    orderBy: { endTimestamp: "desc" },
+                },
+                MainProtocol: true,
+                Chain: true,
+                Protocols: true,
+                Tokens: true,
+            },
+            where: {
+                status: "LIVE",
+                Chain: { id: chainId },
+                Campaigns: {
+                    some: {
+                        endTimestamp: {
+                            gt: now,
+                        },
+                    },
+                },
+            },
+        });
+    }
     static async countMany(query) {
         const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
         return await apiDbClient.opportunity.count(args);

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

@@ -1,6 +1,6 @@
 import { type CreateCampaignModel } from "../campaign";
 import { Prisma } from "../../../../database/api/.generated";
-import { type ChainId } from "@sdk";
+import { type ChainId, type MerklChainId } from "@sdk";
 import type { CreateOpportunityModel, GetOpportunitiesQueryEntity, LightOpportunityFromDB, OpportunityMetadata, OpportunityUnique } from "./opportunity.model";
 import { OpportunityRepository } from "./opportunity.repository";
 export declare abstract class OpportunityService {
@@ -102,7 +102,7 @@ export declare abstract class OpportunityService {
         apr: number;
         dailyRewards: number;
     } & {
-        campaigns: ({
+        campaigns: {
             params: any;
             chain: {
                 name: string;
@@ -145,7 +145,7 @@ export declare abstract class OpportunityService {
             amount: string;
             opportunityId: string;
             creatorAddress: string;
-        } | null)[];
+        }[];
     }) | null>;
     static getUniqueOrThrow(opportunityId: string | OpportunityUnique): Promise<{
         aprRecord: {
@@ -318,6 +318,134 @@ export declare abstract class OpportunityService {
         apr: number;
         dailyRewards: number;
     } | null)[]>;
+    static findLiveWithFirstCampaign(chainId: MerklChainId): Promise<({
+        aprRecord: {
+            cumulated: number;
+            timestamp: bigint;
+            breakdowns: {
+                type: import("../../../../database/api/.generated").$Enums.AprType;
+                id: number;
+                identifier: string;
+                value: number;
+                aprRecordId: string;
+            }[];
+        };
+        tvlRecord: {
+            id: string;
+            total: number;
+            timestamp: bigint;
+            breakdowns: {
+                type: import("../../../../database/api/.generated").$Enums.TvlType;
+                id: number;
+                identifier: string;
+                value: number;
+                tvlRecordId: string;
+            }[];
+        };
+        rewardsRecord: {
+            id: string;
+            total: number;
+            timestamp: bigint;
+            breakdowns: {
+                id: number;
+                value: number;
+                campaignId: string;
+                dailyRewardsRecordId: string;
+                token: {
+                    symbol: string;
+                    name: string | null;
+                    id: string;
+                    chainId: number;
+                    address: string;
+                    icon: string;
+                    decimals: number;
+                    verified: boolean;
+                    price: number | null;
+                };
+                amount: bigint;
+            }[];
+        };
+        id: string;
+        tokens: {
+            symbol: string;
+            name: string | null;
+            id: string;
+            chainId: number;
+            address: string;
+            icon: string;
+            decimals: number;
+            verified: boolean;
+            price: number | null;
+        }[];
+        chain: {
+            name: string;
+            id: number;
+            icon: string;
+        };
+        protocol: {
+            name: string;
+            url: string;
+            description: string;
+            id: string;
+            tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+            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: {
+                name: string;
+                id: number;
+                icon: string;
+            };
+            rewardToken: {
+                symbol: string;
+                name: string | null;
+                id: string;
+                chainId: number;
+                address: string;
+                icon: string;
+                decimals: number;
+                verified: boolean;
+                price: number | null;
+            };
+            distributionChain: {
+                name: string;
+                id: number;
+                icon: string;
+            } | undefined;
+            campaignStatus: {
+                error: string;
+                details: Prisma.JsonValue;
+                status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                campaignId: string;
+                computedUntil: bigint;
+                processingStarted: bigint;
+            };
+            type: import("../../../../database/api/.generated").$Enums.CampaignType;
+            id: string;
+            subType: number | null;
+            startTimestamp: bigint;
+            endTimestamp: bigint;
+            computeChainId: number;
+            distributionChainId: number;
+            campaignId: string;
+            rewardTokenId: string;
+            amount: string;
+            opportunityId: string;
+            creatorAddress: string;
+        }[];
+    })[]>;
     static getAllIds(): Promise<{
         id: string;
     }[]>;

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

@@ -152,6 +152,17 @@ export class OpportunityService {
             }, query);
         });
     }
+    static async findLiveWithFirstCampaign(chainId) {
+        return record("data-layer.access", async () => {
+            return await CacheService.wrap(TTLPresets.MIN_10, async (chainId) => {
+                const opportunities = await OpportunityRepository.findLiveWithFirstCampaign(chainId);
+                return opportunities.map(o => {
+                    const formatted = OpportunityService.formatResponse(o);
+                    return Object.assign(formatted, { campaigns: o.Campaigns.map(CampaignService.format) });
+                });
+            }, chainId);
+        });
+    }
     static async getAllIds() {
         return await OpportunityRepository.getAllIdsForDynamicOpp();
     }

package/dist/src/modules/v4/position/implementations/AjnaPositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+import type { Opportunity } from "../../opportunity";
+import type { PositionFetcher } from "../position.model";
+export declare class AjnaPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<import("..").PositionT[]>;
+}