@merkl/api 0.20.113 → 0.20.115

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

@@ -1,5 +1,5 @@
 import type { Campaign as CampaignResource, CampaignWithParams } from "@/modules/v4/campaign/campaign.model";
-import type { Campaign as CampaignEnum } from "@sdk";
+import type { Campaign as CampaignType } from "@sdk";
 declare const eden: {
     derive: {};
     resolve: {};
@@ -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<{
@@ -16118,7 +16118,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
 export type Opportunity = FromPromise<Api["v4"]["opportunities"]["index"]["get"]>;
 export type Protocol = FromPromise<Api["v4"]["protocols"]["index"]["get"]>;
 export type Campaign = CampaignResource["model"];
-export type CampaignParams<C extends CampaignEnum> = CampaignWithParams<C>["params"];
+export type CampaignParams<C extends CampaignType> = CampaignWithParams<C>["params"];
 export type Chain = FromPromise<Api["v4"]["chains"]["index"]["get"]>;
 export type Explorer = FromPromise<Api["v4"]["chains"]["index"]["get"]>["explorers"][number];
 export type Token = FromPromise<Api["v4"]["tokens"]["index"]["get"]>;

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/dynamicData/implementations/default.d.ts

@@ -1,5 +1,5 @@
-import type { Campaign as CampaignEnum, CampaignParameters, MerklChainId } from "@sdk";
+import type { CampaignParameters, Campaign as CampaignType, MerklChainId } from "@sdk";
 import type { DynamicDataBuilder } from "../interface";
-export declare class DefaultDynamicData implements DynamicDataBuilder<CampaignEnum> {
-    build(_chainId: MerklChainId, campaigns: CampaignParameters<CampaignEnum>[]): Promise<CampaignParameters<CampaignEnum>[]>;
+export declare class DefaultDynamicData implements DynamicDataBuilder<CampaignType> {
+    build(_chainId: MerklChainId, campaigns: CampaignParameters<CampaignType>[]): Promise<CampaignParameters<CampaignType>[]>;
 }

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/Ajna/metadata.d.ts

@@ -1,8 +1,8 @@
 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 Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
-type campaignType = CampaignEnum.AJNA;
+import { type CampaignParameters, type Campaign as CampaignType, type ChainId } from "@sdk";
+type campaignType = CampaignType.AJNA;
 export declare class AjnaMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND" | "BORROW";

package/dist/src/engine/implementations/Ambient/metadata.d.ts

@@ -1,8 +1,8 @@
 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 Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
-type campaignType = CampaignEnum.AMBIENTPROCESSOR;
+import { type CampaignParameters, type Campaign as CampaignType, type ChainId } from "@sdk";
+type campaignType = CampaignType.AMBIENTPROCESSOR;
 export declare class AmbientMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         name: string;

package/dist/src/engine/implementations/Badger/metadata.d.ts

@@ -1,8 +1,8 @@
 import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { CampaignParameters, Campaign as CampaignType, ChainId } from "@sdk";
 import type { MetadataBuilder } from "../../metadata/interface";
-type campaignType = CampaignEnum.BADGER;
+type campaignType = CampaignType.BADGER;
 export declare class BadgerMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "BORROW";

package/dist/src/engine/implementations/Clamm/metadata.d.ts

@@ -1,8 +1,8 @@
 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 Campaign as CampaignEnum, type CampaignParameters, ChainId } from "@sdk";
-type campaignType = CampaignEnum.CLAMM;
+import { type CampaignParameters, type Campaign as CampaignType, ChainId } from "@sdk";
+type campaignType = CampaignType.CLAMM;
 export declare const uniswapV3OkuChains: {
     [ChainId.BLAST]: string;
     [ChainId.SCROLL]: string;

package/dist/src/engine/implementations/Compound/metadata.d.ts

@@ -1,8 +1,8 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
-import { type Campaign as CampaignEnum } from "@sdk";
+import { type Campaign as CampaignType } from "@sdk";
 import type { ProtocolId } from "../../../modules/v4/protocol/protocol.model";
-type campaignType = CampaignEnum.COMPOUND;
+type campaignType = CampaignType.COMPOUND;
 export declare class CompoundMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND" | "BORROW";

package/dist/src/engine/implementations/CompoundV3/metadata.d.ts

@@ -1,8 +1,8 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
-import { type Campaign as CampaignEnum } from "@sdk";
+import { type Campaign as CampaignType } from "@sdk";
 import type { ProtocolId } from "../../../modules/v4/protocol/protocol.model";
-type campaignType = CampaignEnum.COMPOUND_V3;
+type campaignType = CampaignType.COMPOUND_V3;
 export declare class CompoundV3Metadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND" | "BORROW";

package/dist/src/engine/implementations/Default/metadata.d.ts

@@ -1,7 +1,7 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
-import type { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType;
 export declare class DefaultMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "HOLD";

package/dist/src/engine/implementations/Dolomite/metadata.d.ts

@@ -1,8 +1,8 @@
 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 { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum.DOLOMITE;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType.DOLOMITE;
 export declare class DolomiteMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND" | "BORROW";

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

@@ -1,8 +1,8 @@
 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 { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum.EIGENLAYER;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType.EIGENLAYER;
 export declare class EigenLayerMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND";

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/Encompassing/metadata.d.ts

@@ -1,7 +1,7 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
-import type { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum.ENCOMPASSING;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType.ENCOMPASSING;
 export declare class EncompassingMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "DROP";

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

@@ -1,20 +1,9 @@
 import type { Erc20LikeCampaignEnum } from "@/engine/implementations/Erc20/subTypes";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
-import type { OpportunityAction } from "@db/api";
 import type { MetadataBuilder } from "../../metadata/interface";
 type campaignType = Erc20LikeCampaignEnum;
 export declare class Erc20Metadata implements MetadataBuilder<campaignType> {
-    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">, opportunityIdentifier: string): Promise<{
-        name: string;
-        action: OpportunityAction;
-        tokens: {
-            chainId: number;
-            address: string;
-        }[];
-        mainProtocol?: import("../../../modules/v4/protocol/protocol.model").ProtocolId;
-        depositUrl?: string;
-        explorerAddress?: string;
-    } | {
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">, opportunityIdentifier: string): Promise<import("../../metadata/interface").Metadata | {
         action: import("@db/api").$Enums.OpportunityAction;
         name: string;
         tokens: {

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

@@ -1,7 +1,7 @@
 import { dynamicDataBuilderFactory } from "@/engine/deprecated/dynamicData/factory";
 import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
 import { log } from "@/utils/logger";
-import { Campaign as CampaignEnum } from "@sdk";
+import { Campaign as CampaignType } from "@sdk";
 import { getAddress } from "viem";
 import { ProtocolService } from "../../../modules/v4/protocol/protocol.service";
 import { detectSubType } from "./subTypes/detect";
@@ -10,7 +10,7 @@ export class Erc20Metadata {
     async build(campaign, opportunityIdentifier) {
         const { params, computeChainId, campaignId, rewardToken, distributionChainId, type } = campaign;
         const [subType] = await detectSubType(computeChainId, [
-            OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[type], campaign, opportunityIdentifier),
+            OpportunityConvertorService.convertV4CampaignToV3(CampaignType[type], campaign, opportunityIdentifier),
         ]);
         log.info(`building metadata for subtype ${subType}`);
         const builder = erc20SubTypeMetadataBuilderFactory(subType);
@@ -24,7 +24,7 @@ export class Erc20Metadata {
         const depositUrl = params?.url;
         let tokens = [{ chainId: computeChainId, address: params.targetToken }];
         try {
-            const [dynamicData] = await dynamicDataBuilderFactory(CampaignEnum.ERC20).build(computeChainId, [
+            const [dynamicData] = await dynamicDataBuilderFactory(CampaignType.ERC20).build(computeChainId, [
                 {
                     campaignId,
                     rewardToken: rewardToken.address,

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/implementations/Erc20Snapshot/metadata.d.ts

@@ -1,7 +1,7 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
-import type { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum.ERC20_SNAPSHOT;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType.ERC20_SNAPSHOT;
 export declare class Erc20SnapshotMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         name: string;

package/dist/src/engine/implementations/Erc721/metadata.d.ts

@@ -1,7 +1,7 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
-import type { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum.ERC721 | CampaignEnum.ERC721FIXAPR;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType.ERC721 | CampaignType.ERC721FIXAPR;
 export declare class Erc721Metadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "HOLD";

package/dist/src/engine/implementations/ErcMultiToken/metadata.d.ts

@@ -1,8 +1,8 @@
 import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import { type Campaign as CampaignEnum } from "@sdk";
+import { type Campaign as CampaignType } from "@sdk";
 import type { MetadataBuilder } from "../../metadata/interface";
-type campaignType = CampaignEnum.ERC1155 | CampaignEnum.ERC1155FIXAPR | CampaignEnum.ERC6909 | CampaignEnum.ERC6909FIXAPR;
+type campaignType = CampaignType.ERC1155 | CampaignType.ERC1155FIXAPR | CampaignType.ERC6909 | CampaignType.ERC6909FIXAPR;
 export declare class ErcMultiTokenMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "HOLD";

package/dist/src/engine/implementations/Euler/metadata.d.ts

@@ -1,8 +1,8 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import { Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
-type campaignType = CampaignEnum.EULER;
+import { type CampaignParameters, Campaign as CampaignType, type ChainId } from "@sdk";
+type campaignType = CampaignType.EULER;
 export declare class EulerMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         name: string;

package/dist/src/engine/implementations/Euler/metadata.js

@@ -2,14 +2,14 @@ import { dynamicDataBuilderFactory } from "@/engine/deprecated/dynamicData/facto
 import { log } from "@/utils/logger";
 import { sanitizeChainName } from "@/utils/sanitizeChain";
 import { OpportunityAction } from "@db/api";
-import { Campaign as CampaignEnum } from "@sdk";
+import { Campaign as CampaignType } from "@sdk";
 import { getAddress } from "viem";
 export class EulerMetadata {
     async build(campaign) {
         const { params, computeChainId, campaignId, rewardToken, distributionChainId, subType } = campaign;
         let name = `Hold ${params.symbolTargetToken}`;
         try {
-            const [dynamicData] = await dynamicDataBuilderFactory(CampaignEnum.EULER).build(computeChainId, [
+            const [dynamicData] = await dynamicDataBuilderFactory(CampaignType.EULER).build(computeChainId, [
                 {
                     campaignId,
                     rewardToken: rewardToken.address,

package/dist/src/engine/implementations/EventBased/metadata.d.ts

@@ -1,7 +1,7 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
-import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
-type campaignType = CampaignEnum.EVENT_BASED;
+import type { CampaignParameters, Campaign as CampaignType, ChainId } from "@sdk";
+type campaignType = CampaignType.EVENT_BASED;
 export declare class EventBasedMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "SWAP";

package/dist/src/engine/implementations/Hyperdrive/metadata.d.ts

@@ -1,8 +1,8 @@
 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 Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
-type campaignType = CampaignEnum.HYPERDRIVELOGPROCESSOR | CampaignEnum.HYPERDRIVELOGFIXPROCESSOR;
+import { type CampaignParameters, type Campaign as CampaignType, type ChainId } from "@sdk";
+type campaignType = CampaignType.HYPERDRIVELOGPROCESSOR | CampaignType.HYPERDRIVELOGFIXPROCESSOR;
 export declare class HyperdriveMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "POOL" | "LONG" | "SHORT";

package/dist/src/engine/implementations/Invalid/metadata.d.ts

@@ -1,6 +1,6 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
-import type { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum.INVALID;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType.INVALID;
 export declare class InvalidMetadata implements MetadataBuilder<campaignType> {
     build(): Promise<{
         name: string;

package/dist/src/engine/implementations/Ion/metadata.d.ts

@@ -1,8 +1,8 @@
 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 { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum.ION;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType.ION;
 export declare class IonMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND";

package/dist/src/engine/implementations/JsonAirdrop/metadata.d.ts

@@ -1,7 +1,7 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
-import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
-type campaignType = CampaignEnum.JSON_AIRDROP;
+import type { CampaignParameters, Campaign as CampaignType, ChainId } from "@sdk";
+type campaignType = CampaignType.JSON_AIRDROP;
 export declare class JsonAirdropMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "DROP";