@merkl/api 0.20.114 → 0.20.115

package/dist/src/eden/index.d.ts

@@ -1734,8 +1734,8 @@ declare const eden: {
                             authorization: string;
                         };
                         query: {
+                            distributionChain?: number | undefined;
                             campaignId: string;
-                            distributionChain: number;
                         };
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
@@ -7099,8 +7099,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         body: unknown;
                         params: {};
                         query: {
+                            distributionChain?: number | undefined;
                             campaignId: string;
-                            distributionChain: number;
                         };
                         headers: {
                             authorization: string;
@@ -12892,8 +12892,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             authorization: string;
                         };
                         query: {
+                            distributionChain?: number | undefined;
                             campaignId: string;
-                            distributionChain: number;
                         };
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{

package/dist/src/engine/deprecated/dynamicData/factory.js

@@ -61,5 +61,6 @@ const map = {
     [Campaign.ERC1155FIXAPR]: new ERCMultiTokenDynamicData(),
     [Campaign.ERC721]: new ERC721DynamicData(),
     [Campaign.ERC721FIXAPR]: new ERC721DynamicData(),
+    [Campaign.MULTILOG]: new DefaultDynamicData(), // TODO
 };
 export const dynamicDataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/deprecated/dynamicData/implementations/EventBased.js

@@ -69,7 +69,7 @@ export class EventBasedDynamicData {
                 const { distributedRewards } = await computeEventBasedPoolRewardsFromMostRecentStateSave(chainId, campaign.campaignId, priceToken, decimalsCurrency0);
                 const c = campaign;
                 const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
-                const multiplier = BN2Number(c.campaignParameters.topicToData[0].multiplier, 12 + 9);
+                const multiplier = BN2Number(c.campaignParameters.topicToData[0].multipliers[0], 12 + 9);
                 const startTimestamp = BN2Number(c.startTimestamp, 0);
                 const endTimestamp = BN2Number(c.endTimestamp, 0);
                 const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;

package/dist/src/engine/deprecated/erc20SubTypeProcessors/subtypesRound1.js

@@ -190,18 +190,13 @@ function generateResult(type, name, targetToken, typeInfo, campaign) {
     };
     return processorObject.computeRound1(type, typeInfo);
 }
-function processNamingConditions(type, name, targetToken, campaign) {
-    if (satisfiesNameConditions(name, type)) {
-        return generateResult(type, name, targetToken, {}, campaign);
-    }
-}
 export function processNamingConditionsInOrder(name, targetToken, campaign) {
     // Order matters
     const types = Object.values(Erc20SubType).filter(value => typeof value === "string");
     for (const type of types) {
-        const result = processNamingConditions(type, name, targetToken, campaign);
-        if (result)
-            return result;
+        if (satisfiesNameConditions(name, type)) {
+            return generateResult(type, name, targetToken, {}, campaign);
+        }
     }
 }
 function parseForFactory(calls, targetToken, campaign) {

package/dist/src/engine/implementations/EigenLayer/tvl.d.ts

@@ -0,0 +1,7 @@
+import type { TVLBuilder, TVLData } from "@/engine/tvl/interface";
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+type campaignType = Campaign.EIGENLAYER;
+export declare class EigenLayerTVLBuilder implements TVLBuilder<campaignType> {
+    build(computeChainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<TVLData<Campaign.EIGENLAYER>>;
+}
+export {};

package/dist/src/engine/implementations/EigenLayer/tvl.js

@@ -0,0 +1,60 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { log } from "@/utils/logger";
+import { TvlType } from "@db/api";
+import { ChainInteractionService, EigenLayerStrategyInterface, bigIntToNumber, } from "@sdk";
+export class EigenLayerTVLBuilder {
+    async build(computeChainId, campaigns) {
+        const tvls = [];
+        const firstRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
+            const { campaignId, campaignParameters } = campaign;
+            const { strategy } = campaignParameters;
+            return [
+                {
+                    callData: EigenLayerStrategyInterface.encodeFunctionData("totalShares"),
+                    target: strategy,
+                    key: `${campaignId}_totalShares`,
+                    decoder: (data) => BigInt(EigenLayerStrategyInterface.decodeFunctionResult("totalShares", data)[0].toString()),
+                },
+            ];
+        }));
+        const secondRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
+            const { campaignId, campaignParameters } = campaign;
+            const { strategy } = campaignParameters;
+            let totalShares = firstRound[`${campaignId}_totalShares`];
+            if (!totalShares) {
+                log.warn(`Error getting totalShares for campaign ${campaign.campaignId} and strategy ${campaign.campaignParameters.strategy}`);
+                totalShares = 10n;
+            }
+            return [
+                {
+                    callData: EigenLayerStrategyInterface.encodeFunctionData("sharesToUnderlying", [totalShares]),
+                    target: strategy,
+                    key: `${campaignId}_totalUnderlying`,
+                    decoder: (data) => BigInt(EigenLayerStrategyInterface.decodeFunctionResult("sharesToUnderlying", data)[0].toString()),
+                },
+            ];
+        }));
+        for (const campaign of campaigns) {
+            const { campaignId, campaignParameters } = campaign;
+            const { underlyingToken: underlyingTokenAddress } = campaignParameters;
+            const totalUnderlying = secondRound[`${campaignId}_totalUnderlying`];
+            // We don't fetch token data everytime, we use the database and the associated service
+            const underlyingToken = await TokenService.findUniqueFillOrThrow({
+                chainId: computeChainId,
+                address: underlyingTokenAddress,
+            });
+            tvls.push({
+                campaign,
+                tvl: (bigIntToNumber(totalUnderlying, underlyingToken.decimals) ?? 0) * (underlyingToken.price ?? 0),
+                tvlBreakdown: [
+                    {
+                        identifier: underlyingToken.id,
+                        type: TvlType.TOKEN,
+                        value: bigIntToNumber(totalUnderlying, underlyingToken.decimals),
+                    },
+                ],
+            });
+        }
+        return tvls;
+    }
+}

package/dist/src/engine/implementations/Erc20/subTypes/factories.js

@@ -1,6 +1,8 @@
 import { Erc20SubType } from ".";
 import { GearboxMetadata } from "./implementations/gearbox/metadata";
 import { GearboxTVLBuilder } from "./implementations/gearbox/tvl";
+import { SuperlendMetadata } from "./implementations/superlend/metadata";
+import { SuperlendTVLBuilder } from "./implementations/superlend/tvl";
 /**
  * @dev TYPE SAFETY DISABLED FOR NOW AS WE DON'T HAVE ALL THE CAMPAIGNS IMPLEMENTED
  *
@@ -9,6 +11,8 @@ import { GearboxTVLBuilder } from "./implementations/gearbox/tvl";
  */
 const tvlMap = {
     [Erc20SubType.gearbox]: new GearboxTVLBuilder(),
+    [Erc20SubType.superlend_borrowing]: new SuperlendTVLBuilder(),
+    [Erc20SubType.superlend_lending]: new SuperlendTVLBuilder(),
 };
 export const erc20SubTypeTVLBuilderFactory = (erc20Subtype) => {
     if (!tvlMap[erc20Subtype]) {
@@ -24,6 +28,8 @@ export const erc20SubTypeTVLBuilderFactory = (erc20Subtype) => {
  */
 const metadataMap = {
     [Erc20SubType.gearbox]: new GearboxMetadata(),
+    [Erc20SubType.superlend_borrowing]: new SuperlendMetadata(),
+    [Erc20SubType.superlend_lending]: new SuperlendMetadata(),
 };
 export const erc20SubTypeMetadataBuilderFactory = (erc20Subtype) => {
     if (!metadataMap[erc20Subtype]) {

package/dist/src/engine/implementations/Erc20/subTypes/implementations/gearbox/tvl.js

@@ -21,7 +21,7 @@ export class GearboxTVLBuilder {
         for (const [index, campaign] of campaigns.entries()) {
             const underlyingTokenAddress = GearboxVaultInterface.decodeFunctionResult("underlyingToken", result[2 * index].returnData)[0];
             const totalAssets = ERC4626Interface.decodeFunctionResult("totalAssets", result[2 * index + 1].returnData)[0];
-            const underlyingToken = await TokenService.findUniqueOrThrow({
+            const underlyingToken = await TokenService.findUniqueFillOrThrow({
                 chainId: computeChainId,
                 address: underlyingTokenAddress,
             });

package/dist/src/engine/implementations/Erc20/subTypes/implementations/superlend/metadata.d.ts

@@ -0,0 +1,17 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
+import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
+import type { Erc20LikeCampaignEnum } from "../..";
+export declare class SuperlendMetadata implements MetadataBuilder<Erc20LikeCampaignEnum> {
+    build(campaign: Omit<CampaignWithParams<Erc20LikeCampaignEnum>, "manualOverrides">): Promise<{
+        action: "LEND" | "BORROW";
+        protocol: ProtocolId;
+        name: string;
+        tokens: {
+            chainId: number;
+            address: any;
+        }[];
+        depositUrl: string;
+        explorerAddress: any;
+    }>;
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/superlend/metadata.js

@@ -0,0 +1,29 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { OpportunityAction } from "@db/api";
+import { Aave__factory, ChainInteractionService, TokenInteractionService } from "@sdk";
+export class SuperlendMetadata {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
+        const { targetToken } = params;
+        const targetTokenInfo = await TokenService.fetchOnChain({
+            chainId: computeChainId,
+            address: targetToken,
+        });
+        const underlyingToken = await Aave__factory.connect(targetToken, ChainInteractionService(computeChainId).provider()).UNDERLYING_ASSET_ADDRESS();
+        const underlyingTokenSymbol = await TokenInteractionService(computeChainId).symbol(underlyingToken);
+        const action = targetTokenInfo?.name?.toLowerCase().includes("debt")
+            ? OpportunityAction.BORROW
+            : OpportunityAction.LEND;
+        return {
+            action,
+            protocol: "superlend",
+            name: `${action === OpportunityAction.BORROW ? "Borrow" : "Supply"} ${underlyingTokenSymbol} on Superlend`,
+            tokens: [
+                { chainId: computeChainId, address: targetToken },
+                { chainId: computeChainId, address: underlyingToken },
+            ],
+            depositUrl: `https://markets.superlend.xyz/reserve-overview/?underlyingAsset=${underlyingToken}`,
+            explorerAddress: params.targetToken,
+        };
+    }
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/superlend/tvl.d.ts

@@ -0,0 +1,6 @@
+import type { Erc20LikeCampaignEnum } from "@/engine/implementations/Erc20/subTypes";
+import type { TVLBuilder, TVLData } from "@/engine/tvl/interface";
+import { type CampaignParameters, type MerklChainId } from "@sdk";
+export declare class SuperlendTVLBuilder implements TVLBuilder<Erc20LikeCampaignEnum> {
+    build(computeChainId: MerklChainId, campaigns: CampaignParameters<Erc20LikeCampaignEnum>[]): Promise<TVLData<any>>;
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/superlend/tvl.js

@@ -0,0 +1,48 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { TvlType } from "@db/api";
+import { AaveInterface, ChainInteractionService, ERC20Interface, bigIntToNumber, } from "@sdk";
+export class SuperlendTVLBuilder {
+    async build(computeChainId, campaigns) {
+        const tvls = [];
+        const firstRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
+            const { campaignId, campaignParameters } = campaign;
+            const { targetToken } = campaignParameters;
+            return [
+                {
+                    callData: AaveInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
+                    target: targetToken,
+                    key: `${campaignId}_underlyingToken`,
+                    decoder: (data) => AaveInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", data)[0],
+                },
+                {
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: targetToken,
+                    key: `${campaignId}_totalSupply`,
+                    decoder: (data) => BigInt(ERC20Interface.decodeFunctionResult("totalSupply", data)[0].toString()),
+                },
+            ];
+        }));
+        for (const campaign of campaigns) {
+            const { campaignId } = campaign;
+            const underlyingTokenAddress = firstRound[`${campaignId}_underlyingToken`];
+            const totalSupply = firstRound[`${campaignId}_totalSupply`];
+            // We don't fetch token data everytime, we use the database and the associated service
+            const underlyingToken = await TokenService.findUniqueFillOrThrow({
+                chainId: computeChainId,
+                address: underlyingTokenAddress,
+            });
+            tvls.push({
+                campaign,
+                tvl: (bigIntToNumber(totalSupply, underlyingToken.decimals) ?? 0) * (underlyingToken.price ?? 0),
+                tvlBreakdown: [
+                    {
+                        identifier: underlyingToken.id,
+                        type: TvlType.TOKEN,
+                        value: bigIntToNumber(totalSupply, underlyingToken.decimals),
+                    },
+                ],
+            });
+        }
+        return tvls;
+    }
+}

package/dist/src/engine/implementations/Erc20/tvl.js

@@ -93,7 +93,7 @@ export class Erc20TVLBuilder {
         for (const subType of new Set(subTypes)) {
             promises.push(processSubtype(subType));
         }
-        await Promise.allSettled(promises);
+        await Promise.all(promises);
         return tvls;
     }
 }

package/dist/src/engine/metadata/factory.js

@@ -67,5 +67,6 @@ const map = {
     [Campaign.ERC1155FIXAPR]: new ErcMultiTokenMetadata(),
     [Campaign.ERC721]: new Erc721Metadata(),
     [Campaign.ERC721FIXAPR]: new Erc721Metadata(),
+    [Campaign.MULTILOG]: new DefaultMetadata(), // TODO
 };
 export const metadataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/tvl/factory.js

@@ -2,6 +2,7 @@ import { UniswapV4TVLBuilder } from "@/engine/implementations/UniswapV4/tvl";
 import { Campaign } from "@sdk";
 import { AjnaTVLBuilder } from "../implementations/Ajna/tvl";
 import { AmbiantTVLBuilder } from "../implementations/Ambient/tvl";
+import { EigenLayerTVLBuilder } from "../implementations/EigenLayer/tvl";
 import { Erc20TVLBuilder } from "../implementations/Erc20/tvl";
 /**
  * @dev TYPE SAFETY DISABLED FOR NOW AS WE DON'T HAVE ALL THE CAMPAIGNS IMPLEMENTED
@@ -11,6 +12,7 @@ import { Erc20TVLBuilder } from "../implementations/Erc20/tvl";
  */
 const map = {
     [Campaign.AJNA]: new AjnaTVLBuilder(),
+    [Campaign.EIGENLAYER]: new EigenLayerTVLBuilder(),
     [Campaign.AMBIENTPROCESSOR]: new AmbiantTVLBuilder(),
     [Campaign.UNISWAP_V4]: new UniswapV4TVLBuilder(),
     [Campaign.ERC20]: new Erc20TVLBuilder(),

package/dist/src/index.d.ts

@@ -2133,8 +2133,8 @@ declare const app: Elysia<"", false, {
                         body: unknown;
                         params: {};
                         query: {
+                            distributionChain?: number | undefined;
                             campaignId: string;
-                            distributionChain: number;
                         };
                         headers: {
                             authorization: string;

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

@@ -204,8 +204,8 @@ export declare const CampaignTestController: Elysia<"/campaigns", false, {
                     body: unknown;
                     params: {};
                     query: {
+                        distributionChain?: number | undefined;
                         campaignId: string;
-                        distributionChain: number;
                     };
                     headers: {
                         authorization: string;

package/dist/src/modules/v4/campaign/campaign.test.controller.js

@@ -4,11 +4,11 @@ import { BackOfficeGuard } from "@/guards/BackOffice.guard";
 import { AuthorizationHeadersDto } from "@/guards/Engine.guard";
 import { throwOnUnsupportedChainId } from "@/utils/throw";
 import { Campaign as CampaignType } from "@sdk";
-import Elysia from "elysia";
+import Elysia, { t } from "elysia";
 import { DynamicDataSourceIdentifier } from "../dynamicData/dynamicData.model";
 import { DynamicDataService } from "../dynamicData/dynamicData.service";
 import { OpportunityConvertorService } from "../opportunity/opportunity.converter";
-import { CampaignConfigMinimal, CampaignUniqueDto, CampaignsDto } from "./campaign.model";
+import { CampaignConfigMinimal, CampaignsDto } from "./campaign.model";
 import { CampaignService } from "./campaign.service";
 // ─── Routes for dev and test only ──────────────────────────────────────────────
 export const CampaignTestController = new Elysia({
@@ -84,6 +84,14 @@ export const CampaignTestController = new Elysia({
     // ─── Test Opportunity creation through a campaign Id and a chain ───────────────────────
     // @dev Starts from the engine db to debug opportunity creation failing and preventing the api db to be filled
     .get("/metadata", async ({ query }) => {
+    if (!query.distributionChain) {
+        try {
+            query.distributionChain = (await CampaignService.findMany({ campaignId: query.campaignId, test: true }))?.[0]?.distributionChainId;
+        }
+        catch {
+            throw new NotFoundError("Campaign not found");
+        }
+    }
     const engineCampaigns = await CampaignService.findEngineCampaigns([
         {
             distributionChain: query.distributionChain,
@@ -94,5 +102,8 @@ export const CampaignTestController = new Elysia({
         throw new NotFoundError("Campaign not found in engine db");
     return await CampaignService.create(engineCampaigns[0], true);
 }, {
-    query: CampaignUniqueDto,
+    query: t.Object({
+        distributionChain: t.Optional(t.Numeric()),
+        campaignId: t.String(),
+    }),
 }));

package/dist/src/modules/v4/router.d.ts

@@ -2003,8 +2003,8 @@ export declare const v4: Elysia<"/v4", false, {
                         body: unknown;
                         params: {};
                         query: {
+                            distributionChain?: number | undefined;
                             campaignId: string;
-                            distributionChain: number;
                         };
                         headers: {
                             authorization: string;

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

@@ -114,6 +114,26 @@ export declare abstract class TokenService {
     } & {
         price?: number | null | undefined;
     }>;
+    /**
+     * Read token from database, tries to fill it if unexistant
+     * @param chainId
+     * @param address
+     */
+    static findUniqueFillOrThrow(token: TokenUnique): Promise<{
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+    } & {
+        price?: number | null | undefined;
+    }>;
     /**
      * Checks if two tokens are the same based on chainId/address combo
      * @param a token

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

@@ -163,6 +163,25 @@ export class TokenService {
         const id = typeof token === "string" ? token : TokenService.hashId(token);
         return await TokenRepository.findUniqueOrThrow(id);
     }
+    /**
+     * Read token from database, tries to fill it if unexistant
+     * @param chainId
+     * @param address
+     */
+    static async findUniqueFillOrThrow(token) {
+        const id = TokenService.hashId(token);
+        let result = await TokenRepository.findUnique(id);
+        if (!result) {
+            await TokenService.fillAndCreate({
+                chainId: token.chainId,
+                address: token.address,
+                verified: false,
+                icon: "",
+            });
+            result = await TokenRepository.findUniqueOrThrow(id);
+        }
+        return result;
+    }
     /**
      * Checks if two tokens are the same based on chainId/address combo
      * @param a token