@merkl/api 0.20.156 → 0.20.158

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

@@ -1476,6 +1476,19 @@ declare const eden: {
                     };
                 }>>;
             };
+            tvls: ((params: {
+                opportunityId: string | number;
+            }) => {
+                put: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: unknown[];
+                }>>;
+            }) & {};
             index: {
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;
@@ -1748,47 +1761,20 @@ declare const eden: {
                     }>>;
                 };
             };
-            "dry-runtvl": ((params: {
-                campaignId: string | number;
-            }) => {
-                get: (options: {
-                    headers: {
-                        authorization: string;
-                    };
-                    query?: Record<string, unknown> | undefined;
-                    fetch?: RequestInit | undefined;
-                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: unknown[];
-                }>>;
-            }) & {};
-            "dry-runtvls": ((params: {
-                opportunityId: string | number;
-            }) => {
-                get: (options: {
-                    headers: {
-                        authorization: string;
-                    };
-                    query?: Record<string, unknown> | undefined;
-                    fetch?: RequestInit | undefined;
-                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: unknown[];
-                }>>;
-            }) & {};
             "dry-run": {
-                tvls: {
-                    list: {
-                        post: (body: string[], options: {
-                            headers: {
-                                authorization: string;
-                            };
-                            query?: Record<string, unknown> | undefined;
-                            fetch?: RequestInit | undefined;
-                        }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                            200: unknown[];
-                        }>>;
-                    };
-                };
-                tvl: {
+                tvl: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: unknown[];
+                    }>>;
+                }) & {
                     post: (body: {
                         id?: string | undefined;
                         subType?: number | undefined;
@@ -1834,6 +1820,31 @@ declare const eden: {
                         };
                     }>>;
                 };
+                tvls: ((params: {
+                    opportunityId: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: unknown[];
+                    }>>;
+                }) & {
+                    list: {
+                        post: (body: string[], options: {
+                            headers: {
+                                authorization: string;
+                            };
+                            query?: Record<string, unknown> | undefined;
+                            fetch?: RequestInit | undefined;
+                        }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                            200: unknown[];
+                        }>>;
+                    };
+                };
                 metadata: {
                     post: (body: {
                         id?: string | undefined;
@@ -2054,17 +2065,6 @@ declare const eden: {
                 };
             };
         };
-        campaignstvls: ((params: {
-            opportunityId: string | number;
-        }) => {
-            put: (body?: unknown, options?: {
-                headers?: Record<string, unknown> | undefined;
-                query?: Record<string, unknown> | undefined;
-                fetch?: RequestInit | undefined;
-            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: unknown[];
-            }>>;
-        }) & {};
         campaignscount: {
             "by-chains": {
                 get: (options: {
@@ -6840,6 +6840,24 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
+        } & {
+            tvls: {
+                ":opportunityId": {
+                    put: {
+                        body: unknown;
+                        params: {
+                            opportunityId: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: unknown[];
+                        };
+                    };
+                };
+            };
         } & {
             index: {
                 get: {
@@ -7120,21 +7138,6 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
-        campaignstvls: {
-            ":opportunityId": {
-                put: {
-                    body: unknown;
-                    params: {
-                        opportunityId: string;
-                    };
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: unknown[];
-                    };
-                };
-            };
-        };
     } & {
         campaigns: {
             index: {
@@ -7416,37 +7419,41 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
 } & {
     v4: {
         campaigns: {
-            "dry-runtvl": {
-                ":campaignId": {
-                    get: {
-                        body: unknown;
-                        params: {
-                            campaignId: string;
-                        };
-                        query: unknown;
-                        headers: {
-                            authorization: string;
-                        };
-                        response: {
-                            200: unknown[];
+            "dry-run": {
+                tvl: {
+                    ":campaignId": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: unknown[];
+                            };
                         };
                     };
                 };
             };
         } & {
-            "dry-runtvls": {
-                ":opportunityId": {
-                    get: {
-                        body: unknown;
-                        params: {
-                            opportunityId: string;
-                        };
-                        query: unknown;
-                        headers: {
-                            authorization: string;
-                        };
-                        response: {
-                            200: unknown[];
+            "dry-run": {
+                tvls: {
+                    ":opportunityId": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                opportunityId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: unknown[];
+                            };
                         };
                     };
                 };
@@ -13285,6 +13292,19 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 }>>;
             };
+            tvls: ((params: {
+                opportunityId: string | number;
+            }) => {
+                put: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: unknown[];
+                }>>;
+            }) & {};
             index: {
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;
@@ -13557,47 +13577,20 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     }>>;
                 };
             };
-            "dry-runtvl": ((params: {
-                campaignId: string | number;
-            }) => {
-                get: (options: {
-                    headers: {
-                        authorization: string;
-                    };
-                    query?: Record<string, unknown> | undefined;
-                    fetch?: RequestInit | undefined;
-                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: unknown[];
-                }>>;
-            }) & {};
-            "dry-runtvls": ((params: {
-                opportunityId: string | number;
-            }) => {
-                get: (options: {
-                    headers: {
-                        authorization: string;
-                    };
-                    query?: Record<string, unknown> | undefined;
-                    fetch?: RequestInit | undefined;
-                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: unknown[];
-                }>>;
-            }) & {};
             "dry-run": {
-                tvls: {
-                    list: {
-                        post: (body: string[], options: {
-                            headers: {
-                                authorization: string;
-                            };
-                            query?: Record<string, unknown> | undefined;
-                            fetch?: RequestInit | undefined;
-                        }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                            200: unknown[];
-                        }>>;
-                    };
-                };
-                tvl: {
+                tvl: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: unknown[];
+                    }>>;
+                }) & {
                     post: (body: {
                         id?: string | undefined;
                         subType?: number | undefined;
@@ -13643,6 +13636,31 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         };
                     }>>;
                 };
+                tvls: ((params: {
+                    opportunityId: string | number;
+                }) => {
+                    get: (options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: unknown[];
+                    }>>;
+                }) & {
+                    list: {
+                        post: (body: string[], options: {
+                            headers: {
+                                authorization: string;
+                            };
+                            query?: Record<string, unknown> | undefined;
+                            fetch?: RequestInit | undefined;
+                        }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                            200: unknown[];
+                        }>>;
+                    };
+                };
                 metadata: {
                     post: (body: {
                         id?: string | undefined;
@@ -13863,17 +13881,6 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
-        campaignstvls: ((params: {
-            opportunityId: string | number;
-        }) => {
-            put: (body?: unknown, options?: {
-                headers?: Record<string, unknown> | undefined;
-                query?: Record<string, unknown> | undefined;
-                fetch?: RequestInit | undefined;
-            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: unknown[];
-            }>>;
-        }) & {};
         campaignscount: {
             "by-chains": {
                 get: (options: {

package/dist/src/engine/deprecated/erc20SubTypeProcessors/helpers/ownerFinder.js

@@ -4,6 +4,7 @@ const ownerAddresses = {
     "0x42a856dbEBB97AbC1269EAB32f3bb40C15102819": Erc20SubType.satlayer,
     "0x4C911bf7A008C497719CBEb1a376f1cEc9e2c1d6": Erc20SubType.hanji_liquidity_vault_token,
     "0x6e9d701fB6478Ed5972a37886C2BA6C82a4cBb4C": Erc20SubType.gamma, // Gamma Bob owner
+    "0x14fB20565a11b15cA2065A06740A0C46F5986eD0": Erc20SubType.lendle_vaults, // Gamma Alice owner
 };
 export function getTypeFromOwnerAddress(address) {
     if (ownerAddresses[address]) {

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

@@ -3,6 +3,8 @@ import { EulerMetadata } from "./implementations/euler/metadata";
 import { EulerTVLBuilder } from "./implementations/euler/tvl";
 import { GearboxMetadata } from "./implementations/gearbox/metadata";
 import { GearboxTVLBuilder } from "./implementations/gearbox/tvl";
+import { LendleMetadata } from "./implementations/lendleVaults/metadata";
+import { LendleTVLBuilder } from "./implementations/lendleVaults/tvl";
 import { SuperlendMetadata } from "./implementations/superlend/metadata";
 import { SuperlendTVLBuilder } from "./implementations/superlend/tvl";
 /**
@@ -17,6 +19,7 @@ const tvlMap = {
     [Erc20SubType.superlend_lending]: new SuperlendTVLBuilder(),
     [Erc20SubType.euler_borrow]: new EulerTVLBuilder(),
     [Erc20SubType.euler_lend]: new EulerTVLBuilder(),
+    [Erc20SubType.lendle_vaults]: new LendleTVLBuilder(),
 };
 export const erc20SubTypeTVLBuilderFactory = (erc20Subtype) => {
     if (!tvlMap[erc20Subtype]) {
@@ -36,6 +39,7 @@ const metadataMap = {
     [Erc20SubType.superlend_lending]: new SuperlendMetadata(),
     [Erc20SubType.euler_borrow]: new EulerMetadata(),
     [Erc20SubType.euler_lend]: new EulerMetadata(),
+    [Erc20SubType.lendle_vaults]: new LendleMetadata(),
 };
 export const erc20SubTypeMetadataBuilderFactory = (erc20Subtype) => {
     if (!metadataMap[erc20Subtype]) {

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

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

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

@@ -0,0 +1,20 @@
+import { OpportunityAction } from "@db/api";
+import { ChainInteractionService, LendleVault__factory, TokenInteractionService } from "@sdk";
+export class LendleMetadata {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
+        const { targetToken } = params;
+        const underlyingToken = await LendleVault__factory.connect(targetToken, ChainInteractionService(computeChainId).provider()).want();
+        const underlyingTokenSymbol = await TokenInteractionService(computeChainId).symbol(underlyingToken);
+        return {
+            action: OpportunityAction.LEND,
+            mainProtocol: "lendle",
+            name: `Deposit ${underlyingTokenSymbol} on Lendle vaults`,
+            tokens: [
+                { chainId: computeChainId, address: targetToken },
+                { chainId: computeChainId, address: underlyingToken },
+            ],
+            explorerAddress: params.targetToken,
+        };
+    }
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/lendleVaults/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 LendleTVLBuilder implements TVLBuilder<Erc20LikeCampaignEnum> {
+    build(computeChainId: MerklChainId, campaigns: CampaignParameters<Erc20LikeCampaignEnum>[]): Promise<TVLData<any>>;
+}

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

@@ -0,0 +1,53 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { TvlType } from "@db/api";
+import { ChainInteractionService, LendleVaultInterface, bigIntToNumber, } from "@sdk";
+export class LendleTVLBuilder {
+    async build(computeChainId, campaigns) {
+        const tvls = [];
+        const calls = [];
+        for (const campaign of campaigns) {
+            const { targetToken } = campaign.campaignParameters;
+            calls.push({
+                allowFailure: true,
+                callData: LendleVaultInterface.encodeFunctionData("want"),
+                target: targetToken,
+            }, {
+                allowFailure: true,
+                callData: LendleVaultInterface.encodeFunctionData("getPricePerFullShare"),
+                target: targetToken,
+            }, {
+                allowFailure: true,
+                callData: LendleVaultInterface.encodeFunctionData("totalSupply"),
+                target: targetToken,
+            });
+        }
+        const result = await ChainInteractionService(computeChainId).fetchState(calls);
+        for (const [index, campaign] of campaigns.entries()) {
+            const underlyingTokenAddress = LendleVaultInterface.decodeFunctionResult("want", result[3 * index].returnData)[0];
+            const underlyingPerShare = LendleVaultInterface.decodeFunctionResult("getPricePerFullShare", result[3 * index + 1].returnData)[0];
+            const totalSupply = LendleVaultInterface.decodeFunctionResult("totalSupply", result[3 * index + 2].returnData)[0];
+            const underlyingToken = await TokenService.findUniqueFillOrThrow({
+                chainId: computeChainId,
+                address: underlyingTokenAddress,
+            });
+            if (!underlyingToken.decimals || !underlyingToken.price) {
+                throw new Error(`Missing decimals or price for token ${underlyingToken.address}`);
+            }
+            const totalAssets = bigIntToNumber(underlyingPerShare, 18) *
+                bigIntToNumber(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+            const tvl = totalAssets * underlyingToken.price;
+            tvls.push({
+                campaign,
+                tvl,
+                tvlBreakdown: [
+                    {
+                        identifier: underlyingToken.id,
+                        type: TvlType.TOKEN,
+                        value: totalAssets,
+                    },
+                ],
+            });
+        }
+        return tvls;
+    }
+}

package/dist/src/engine/implementations/Erc20/subTypes/index.d.ts

@@ -106,5 +106,6 @@ export declare enum Erc20SubType {
     sake_borrowing = "sake_borrowing",
     sake_lending = "sake_lending",
     gamma = "gamma",
-    stability = "stability"
+    stability = "stability",
+    lendle_vaults = "lendle_vaults"
 }

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

@@ -106,4 +106,5 @@ export var Erc20SubType;
     Erc20SubType["sake_lending"] = "sake_lending";
     Erc20SubType["gamma"] = "gamma";
     Erc20SubType["stability"] = "stability";
+    Erc20SubType["lendle_vaults"] = "lendle_vaults";
 })(Erc20SubType || (Erc20SubType = {}));

package/dist/src/index.d.ts

@@ -1552,6 +1552,24 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
+        } & {
+            tvls: {
+                ":opportunityId": {
+                    put: {
+                        body: unknown;
+                        params: {
+                            opportunityId: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: unknown[];
+                        };
+                    };
+                };
+            };
         } & {
             index: {
                 get: {
@@ -1832,21 +1850,6 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
-        campaignstvls: {
-            ":opportunityId": {
-                put: {
-                    body: unknown;
-                    params: {
-                        opportunityId: string;
-                    };
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: unknown[];
-                    };
-                };
-            };
-        };
     } & {
         campaigns: {
             index: {
@@ -2128,37 +2131,41 @@ declare const app: Elysia<"", false, {
 } & {
     v4: {
         campaigns: {
-            "dry-runtvl": {
-                ":campaignId": {
-                    get: {
-                        body: unknown;
-                        params: {
-                            campaignId: string;
-                        };
-                        query: unknown;
-                        headers: {
-                            authorization: string;
-                        };
-                        response: {
-                            200: unknown[];
+            "dry-run": {
+                tvl: {
+                    ":campaignId": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: unknown[];
+                            };
                         };
                     };
                 };
             };
         } & {
-            "dry-runtvls": {
-                ":opportunityId": {
-                    get: {
-                        body: unknown;
-                        params: {
-                            opportunityId: string;
-                        };
-                        query: unknown;
-                        headers: {
-                            authorization: string;
-                        };
-                        response: {
-                            200: unknown[];
+            "dry-run": {
+                tvls: {
+                    ":opportunityId": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                opportunityId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: unknown[];
+                            };
                         };
                     };
                 };