@merkl/api 0.10.421 → 0.10.422

package/dist/src/index.d.ts

@@ -411,6 +411,7 @@ declare const app: Elysia<"", false, {
                                 tags: string[];
                                 icon: string;
                             } | null | undefined;
+                            depositUrl?: string | undefined;
                             aprRecord?: {
                                 timestamp: string | bigint;
                                 cumulated: number;
@@ -422,7 +423,6 @@ declare const app: Elysia<"", false, {
                                     aprRecordId: string;
                                 }[];
                             } | undefined;
-                            depositUrl?: string | undefined;
                             tvlRecord?: {
                                 total: number;
                                 timestamp: string | bigint;
@@ -535,6 +535,7 @@ declare const app: Elysia<"", false, {
                                 tags: string[];
                                 icon: string;
                             } | null | undefined;
+                            depositUrl?: string | undefined;
                             aprRecord?: {
                                 timestamp: string | bigint;
                                 cumulated: number;
@@ -546,7 +547,6 @@ declare const app: Elysia<"", false, {
                                     aprRecordId: string;
                                 }[];
                             } | undefined;
-                            depositUrl?: string | undefined;
                             tvlRecord?: {
                                 total: number;
                                 timestamp: string | bigint;
@@ -694,6 +694,7 @@ declare const app: Elysia<"", false, {
                                     tags: string[];
                                     icon: string;
                                 } | null | undefined;
+                                depositUrl?: string | undefined;
                                 aprRecord?: {
                                     timestamp: string | bigint;
                                     cumulated: number;
@@ -705,7 +706,6 @@ declare const app: Elysia<"", false, {
                                         aprRecordId: string;
                                     }[];
                                 } | undefined;
-                                depositUrl?: string | undefined;
                                 tvlRecord?: {
                                     total: number;
                                     timestamp: string | bigint;
@@ -1186,10 +1186,10 @@ declare const app: Elysia<"", false, {
                         response: {
                             200: {
                                 endTimestamp: bigint;
+                                campaignId: string;
                                 CampaignStatus: {
                                     computedUntil: bigint;
                                 }[];
-                                campaignId: string;
                             }[];
                         };
                     };
@@ -1706,12 +1706,8 @@ declare const app: Elysia<"", false, {
                             };
                             headers: unknown;
                             response: {
-                                200: {
-                                    amount: string;
-                                    claimed: string;
-                                    pending: string;
-                                    recipient: string;
-                                }[];
+                                [x: string]: any;
+                                200: any;
                             };
                         };
                     };
@@ -1775,12 +1771,8 @@ declare const app: Elysia<"", false, {
                         };
                         headers: unknown;
                         response: {
-                            200: {
-                                amount: string;
-                                claimed: string;
-                                pending: string;
-                                recipient: string;
-                            }[];
+                            [x: string]: any;
+                            200: any;
                         };
                     };
                 };
@@ -3097,13 +3089,13 @@ declare const app: Elysia<"", false, {
                         chainId?: number | undefined;
                         startTimestamp?: string | undefined;
                         endTimestamp?: string | undefined;
-                        campaignStatus?: {} | undefined;
                         distributionChainId?: number | undefined;
                         campaignId?: string | undefined;
                         rewardTokenId?: string | undefined;
                         amount?: string | undefined;
                         opportunityId?: string | undefined;
                         creatorAddress?: string | undefined;
+                        campaignStatus?: {} | undefined;
                         rewardToken?: {} | undefined;
                         rewardTokenAddress?: string | undefined;
                         distributionChain?: {} | undefined;
@@ -3277,6 +3269,12 @@ declare const app: Elysia<"", false, {
                                 delayFormatted: string;
                                 startTimestamp: bigint;
                                 endTimestamp: bigint;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                Opportunity: {
+                                    name: string;
+                                };
                                 CampaignStatus: {
                                     error: string;
                                     details: import("database/api/.generated/runtime/library").JsonValue;
@@ -3285,12 +3283,6 @@ declare const app: Elysia<"", false, {
                                     computedUntil: bigint;
                                     processingStarted: bigint;
                                 }[];
-                                Opportunity: {
-                                    name: string;
-                                };
-                                computeChainId: number;
-                                distributionChainId: number;
-                                campaignId: string;
                             }[];
                         };
                     };

package/dist/src/index.js

@@ -95,7 +95,7 @@ const app = new Elysia({
     .use(v4)
     .use(v3)
     .use(errorHandler())
-    .listen(PORT, ({ hostname, port }) => {
+    .listen({ port: PORT, idleTimeout: 40 }, ({ hostname, port }) => {
     log.info(`🌐  Api started (${hostname}:${port})`);
 });
 // ─── Signal Handling ─────────────────────────────────────────────────────────

package/dist/src/libs/campaigns/utils/getEulerV2Vaults.d.ts

@@ -1,10 +1,15 @@
 import { type MerklChainId } from "@sdk";
+export declare enum LoggedEntityType {
+    EULER = "EULER_VAULT",
+    UNISWAP_V4 = "UNISWAP_V4"
+}
 export type EulerVaultType = {
     address: string;
     asset: string;
     chainId: MerklChainId;
     debtTokenAddress: string;
     name: string;
+    fetchedAtBlock: number;
     collaterals: {
         address: string;
         borrowLTV: string;

package/dist/src/libs/campaigns/utils/getEulerV2Vaults.js

@@ -1,17 +1,42 @@
 import { Redis } from "../../../cache";
 import { batchMulticallCallWithRetry } from "../../../utils/generic";
 import { log } from "../../../utils/logger";
+import { apiDbClient } from "../../../utils/prisma";
 import { providers } from "../../../utils/providers";
-import { ERC20Interface, EULER_ADDRESSES, EVC_CREATION_BLOCK, EulerEVKInterface, EulerVaultLensInterface, EulerVault__factory, NETWORK_LABELS, eulerChainds, } from "@sdk";
+import { ChainInteractionService, ERC20Interface, EULER_ADDRESSES, EulerEVKInterface, EulerVaultLensInterface, EulerVault__factory, NETWORK_LABELS, eulerChainIds, getContractCreationBlock, } from "@sdk";
 import { getAddress } from "ethers/lib/utils";
 import { fetchEulerVaultName } from "../campaignTypes/ERC20SubTypes/helpers/eulerVaultNames";
 import { safeFetchLogs } from "./fetchLogs";
+export var LoggedEntityType;
+(function (LoggedEntityType) {
+    LoggedEntityType["EULER"] = "EULER_VAULT";
+    LoggedEntityType["UNISWAP_V4"] = "UNISWAP_V4";
+})(LoggedEntityType || (LoggedEntityType = {}));
 async function getEulerV2Vaults() {
     let vaults = [];
-    for (const chainId of eulerChainds) {
+    // 0_ Fetch all euler vaults from database
+    const storedVaults = await apiDbClient.logged.findMany({
+        where: { type: LoggedEntityType.EULER },
+    });
+    const res = await Promise.all(eulerChainIds.map(async (chainId) => {
+        let vaultsPerChain = [];
+        chainId = chainId;
         try {
-            const fromBlock = EVC_CREATION_BLOCK[chainId] ?? 0; // EVC contract creation block
+            // 1_ Get latest euler vaults from chain
+            const storedVaultsPerChain = storedVaults.filter(vault => vault.chainId === chainId);
+            log.info(`found ${storedVaultsPerChain.length} already stored vaults on ${NETWORK_LABELS[chainId]}`);
+            let fromBlock;
+            if (storedVaultsPerChain.length > 0) {
+                fromBlock = Math.max(...storedVaultsPerChain.map(vault => vault.fetchAtBlock)) + 1;
+            }
+            else {
+                fromBlock = await getContractCreationBlock(EULER_ADDRESSES[chainId].VAULT_FACTORY, ChainInteractionService(chainId).provider());
+            }
             const toBlock = await providers[chainId].getBlockNumber();
+            // Check
+            if (fromBlock >= toBlock) {
+                throw new Error(`fromBlock ${fromBlock} is greater than toBlock ${toBlock}`);
+            }
             const logs = await safeFetchLogs(chainId, [EulerEVKInterface.getEventTopic("EVaultCreated")], [], fromBlock, toBlock);
             const decodedVaults = await Promise.all(logs.map(async (log) => {
                 const aux = EulerEVKInterface.decodeEventLog("EVaultCreated", log.data, log.topics);
@@ -21,6 +46,7 @@ async function getEulerV2Vaults() {
                 return {
                     address: log.address.toString(),
                     asset: aux[1].toString(),
+                    fetchedAtBlock: Number(log.blockNumber),
                     chainId: chainId,
                     debtTokenAddress: aux[2].toString(),
                     name: vaultName,
@@ -67,7 +93,7 @@ async function getEulerV2Vaults() {
             const resCollatUnderlyingSymbol = await batchMulticallCallWithRetry(chainId, {
                 calls: callsCollatUnderlyingSymbol,
             });
-            vaults = vaults.concat((await Promise.all(decodedVaults.map(async (decodedVault, index) => {
+            vaultsPerChain = vaultsPerChain.concat((await Promise.all(decodedVaults.map(async (decodedVault, index) => {
                 const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
                 const collaterals = [];
                 for (const [_index, collat] of collatArray.entries()) {
@@ -82,11 +108,44 @@ async function getEulerV2Vaults() {
                 }
                 return { ...decodedVault, collaterals };
             }))));
+            return vaultsPerChain;
         }
         catch (e) {
             log.error(`issue when fetching vaults on ${NETWORK_LABELS[chainId]}`, e);
         }
+        return vaultsPerChain;
+    }));
+    for (const resPerChain of res) {
+        if (!!resPerChain && resPerChain.length > 0) {
+            vaults = vaults.concat(resPerChain);
+        }
+    }
+    // Update the API database
+    if (vaults.length > 0) {
+        try {
+            await apiDbClient.logged.createMany({
+                data: vaults.map(vault => ({
+                    fetchAtBlock: vault.fetchedAtBlock,
+                    caughtFromAddress: EULER_ADDRESSES[vault.chainId].VAULT_FACTORY,
+                    chainId: vault.chainId,
+                    address: vault.address,
+                    entityData: vault,
+                    id: Bun.hash(`${vault.address}-${vault.chainId}`).toString(),
+                    type: LoggedEntityType.EULER,
+                })),
+            });
+            log.info(`✅ successfully saved ${vaults.length} new vault(s) to API database ('Logged' table)`);
+        }
+        catch {
+            throw new Error("Error while saving vaults to API database (`Logged` table)");
+        }
+    }
+    log.info("✅ successfully fetched vaults on Euler V2");
+    // FIXME _ Merge previoulsy stored vaults with newly fetched ones
+    if (storedVaults.length > 0) {
+        vaults = vaults.concat(storedVaults.map(v => v.entityData));
     }
+    log.info("👋 exiting getEulerV2Vaults");
     return vaults;
 }
 export const getEulerV2VaultsWithCache = async () => await Redis.getOrSet("EulerV2Vaults", getEulerV2Vaults);

package/dist/src/libs/campaigns/utils/getUniswapV4Pools.js

@@ -1,18 +1,33 @@
 import { Redis } from "../../../cache";
 import { log } from "../../../utils/logger";
+import { apiDbClient } from "../../../utils/prisma";
 import { providers } from "../../../utils/providers";
 import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, PoolManagerInterface, UniswapV4Addresses, getContractCreationBlock, } from "@sdk";
 import { safeFetchLogs } from "./fetchLogs";
+import { LoggedEntityType } from "./getEulerV2Vaults";
 const UNIV4_CHAINIDS = Object.keys(UniswapV4Addresses).map((x) => Number(x));
 async function getUniswapV4Pools() {
     const pools = {};
+    // 0_ Fetch all euler vaults from database
+    const storedPools = await apiDbClient.logged.findMany({
+        where: { type: LoggedEntityType.UNISWAP_V4 },
+    });
     const res = await Promise.all(UNIV4_CHAINIDS.map(async (chainId) => {
         chainId = chainId;
         const perChainIdRes = {};
         const poolManagerAddress = UniswapV4Addresses[chainId]?.PoolManager ?? NULL_ADDRESS;
         const jsonRPCprovider = providers[chainId];
         try {
-            const fromBlock = await getContractCreationBlock(poolManagerAddress, jsonRPCprovider);
+            // 1_ Get latest euler vaults from chain
+            const storedPoolsPerChain = storedPools.filter(pool => pool.chainId === chainId);
+            log.info(`found ${storedPoolsPerChain.length} already stored vaults on ${NETWORK_LABELS[chainId]}`);
+            let fromBlock;
+            if (storedPoolsPerChain.length > 0) {
+                fromBlock = Math.max(...storedPools.map(x => x.fetchAtBlock)) + 1;
+            }
+            else {
+                fromBlock = await getContractCreationBlock(poolManagerAddress, jsonRPCprovider);
+            }
             const toBlock = await jsonRPCprovider.getBlockNumber();
             const logs = await safeFetchLogs(chainId, // TODO: rm type enforcing
             [PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock);
@@ -27,7 +42,7 @@ async function getUniswapV4Pools() {
                     tickSpacing: tickSpacing,
                     lpFee: fee,
                     hooks: hooks,
-                    initializeBlock: Number(log.blockNumber),
+                    fetchedAtBlock: Number(log.blockNumber),
                 };
             }));
             log.local(`fetched ${decodedPools.length} pool(s) on ${NETWORK_LABELS[chainId] ?? "Sepolia"} between blocks ${fromBlock} and ${toBlock}`);
@@ -58,22 +73,32 @@ async function getUniswapV4Pools() {
             }));
             let index = 0;
             for (const pool of decodedPools) {
-                let symbolCurrency0;
-                let decimalsCurrency0;
+                let symbolCurrency0 = "UNKNOWN";
+                let decimalsCurrency0 = 18;
                 if (pool.currency0 !== NULL_ADDRESS) {
-                    symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index].returnData)[0];
-                    decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 1].returnData)[0];
+                    try {
+                        symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index].returnData)[0];
+                        decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 1].returnData)[0];
+                    }
+                    catch {
+                        log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency0 ${pool.currency0} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                    }
                 }
                 else {
                     symbolCurrency0 = "ETH";
                     decimalsCurrency0 = 18;
                     index -= 2;
                 }
-                let symbolCurrency1;
-                let decimalsCurrency1;
+                let symbolCurrency1 = "UNKNOWN";
+                let decimalsCurrency1 = 18;
                 if (pool.currency1 !== NULL_ADDRESS) {
-                    symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index + 2].returnData)[0];
-                    decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 3].returnData)[0];
+                    try {
+                        symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index + 2].returnData)[0];
+                        decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 3].returnData)[0];
+                    }
+                    catch {
+                        log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency1 ${pool.currency1} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                    }
                 }
                 else {
                     symbolCurrency1 = "ETH";
@@ -88,7 +113,7 @@ async function getUniswapV4Pools() {
                     decimalsCurrency0,
                     decimalsCurrency1,
                     hooks: pool.hooks,
-                    initializeBlock: pool.initializeBlock,
+                    fetchedAtBlock: pool.fetchedAtBlock,
                     lpFee: pool.lpFee,
                     poolId: id,
                     poolKey: pool.poolKey,
@@ -105,9 +130,43 @@ async function getUniswapV4Pools() {
         return perChainIdRes;
     }));
     UNIV4_CHAINIDS.forEach((chainId, i) => {
-        pools[chainId] = res[i];
+        if (!!res[i])
+            pools[chainId] = res[i];
     });
-    log.info("✅ successfully fetched pools on UniswapV4");
+    // Update the API database
+    const tableData = Object.values(pools).flatMap(pools => Object.values(pools));
+    if (Object.values(pools).length > 0) {
+        try {
+            await apiDbClient.logged.createMany({
+                data: tableData.map(pool => ({
+                    fetchAtBlock: pool.fetchedAtBlock,
+                    caughtFromAddress: UniswapV4Addresses[pool.chainId]?.PoolManager ?? NULL_ADDRESS,
+                    chainId: pool.chainId,
+                    entityData: pool,
+                    id: Bun.hash(`${pool.poolId}-${pool.chainId}`).toString(),
+                    type: LoggedEntityType.UNISWAP_V4,
+                })),
+            });
+            log.info("✅ successfully saved vaults to API database (`Logged` table)");
+            // }
+        }
+        catch (e) {
+            log.error("getUniswapV4Pools/LoggedTableUpdate", e);
+            throw new Error("Error while saving UniV4 pools to API database (`Logged` table)");
+        }
+    }
+    log.info(`✅ successfully fetched ${tableData.length} new pool(s) on UniswapV4`);
+    // _ Merge previoulsy stored pools with newly fetched ones
+    // TODO optimize this part
+    if (storedPools.length > 0) {
+        for (const pool of storedPools) {
+            const chainId = pool.chainId;
+            if (!pools[chainId])
+                pools[chainId] = {};
+            pools[chainId][pool.entityData.poolId] = pool.entityData;
+        }
+    }
+    log.info("👋 exiting getUniswapV4Pools");
     return pools;
 }
 export const getUniswapV4PoolsWithCache = async () => await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools);

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

@@ -222,10 +222,10 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                     response: {
                         200: {
                             endTimestamp: bigint;
+                            campaignId: string;
                             CampaignStatus: {
                                 computedUntil: bigint;
                             }[];
-                            campaignId: string;
                         }[];
                     };
                 };

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

@@ -141,20 +141,12 @@ export declare abstract class CampaignRepository {
     }>;
     static findCampaignsToProcess(distributionChainId: ChainId): Promise<{
         endTimestamp: bigint;
+        campaignId: string;
         CampaignStatus: {
             computedUntil: bigint;
         }[];
-        campaignId: string;
     }[]>;
     static findMany(query: GetCampaignQueryModel): Promise<({
-        CampaignStatus: {
-            error: string;
-            details: Prisma.JsonValue;
-            status: import("../../../../database/api/.generated").$Enums.RunStatus;
-            campaignId: string;
-            computedUntil: bigint;
-            processingStarted: bigint;
-        }[];
         ComputeChain: {
             name: string;
             id: number;
@@ -178,6 +170,14 @@ export declare abstract class CampaignRepository {
             isTest: 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;

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

@@ -132,10 +132,10 @@ export declare abstract class CampaignService {
     }>;
     static findCampaignsToProcess(distributionChainId: ChainId): Promise<{
         endTimestamp: bigint;
+        campaignId: string;
         CampaignStatus: {
             computedUntil: bigint;
         }[];
-        campaignId: string;
     }[]>;
     static pickCampaignToProcess(chainId: ChainId): Promise<string>;
     static fill(campaigns: CampaignUnique[]): Promise<{

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

@@ -51,13 +51,13 @@ export declare const DynamicDataController: Elysia<"/dynamic-data", false, {
                     chainId?: number | undefined;
                     startTimestamp?: string | undefined;
                     endTimestamp?: string | undefined;
-                    campaignStatus?: {} | undefined;
                     distributionChainId?: number | undefined;
                     campaignId?: string | undefined;
                     rewardTokenId?: string | undefined;
                     amount?: string | undefined;
                     opportunityId?: string | undefined;
                     creatorAddress?: string | undefined;
+                    campaignStatus?: {} | undefined;
                     rewardToken?: {} | undefined;
                     rewardTokenAddress?: string | undefined;
                     distributionChain?: {} | undefined;

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

@@ -49,12 +49,11 @@ export class InteractionService {
     }
     static async getTargets(chainId, protocolId, identifier) {
         const targets = [];
-        const ensoTarget = await InteractionService.getTargetFromEnso(chainId, protocolId, identifier);
+        // const ensoTarget = await InteractionService.getTargetFromEnso(chainId, protocolId, identifier);
         const zapTarget = InteractionService.getTargetFromKyberZap(chainId, protocolId, identifier);
         if (zapTarget)
             targets.push(zapTarget);
-        if (ensoTarget)
-            targets.push(ensoTarget);
+        // if (ensoTarget) targets.push(ensoTarget);
         return targets;
     }
     /**

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

@@ -266,6 +266,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                             tags: string[];
                             icon: string;
                         } | null | undefined;
+                        depositUrl?: string | undefined;
                         aprRecord?: {
                             timestamp: string | bigint;
                             cumulated: number;
@@ -277,7 +278,6 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                                 aprRecordId: string;
                             }[];
                         } | undefined;
-                        depositUrl?: string | undefined;
                         tvlRecord?: {
                             total: number;
                             timestamp: string | bigint;
@@ -390,6 +390,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                             tags: string[];
                             icon: string;
                         } | null | undefined;
+                        depositUrl?: string | undefined;
                         aprRecord?: {
                             timestamp: string | bigint;
                             cumulated: number;
@@ -401,7 +402,6 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                                 aprRecordId: string;
                             }[];
                         } | undefined;
-                        depositUrl?: string | undefined;
                         tvlRecord?: {
                             total: number;
                             timestamp: string | bigint;
@@ -549,6 +549,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                                 tags: string[];
                                 icon: string;
                             } | null | undefined;
+                            depositUrl?: string | undefined;
                             aprRecord?: {
                                 timestamp: string | bigint;
                                 cumulated: number;
@@ -560,7 +561,6 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                                     aprRecordId: string;
                                 }[];
                             } | undefined;
-                            depositUrl?: string | undefined;
                             tvlRecord?: {
                                 total: number;
                                 timestamp: string | bigint;

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

@@ -165,6 +165,11 @@ export declare const OpportunityWithCampaignsResourceDto: import("@sinclair/type
         icon: import("@sinclair/typebox").TString;
     }>;
     chainId: import("@sinclair/typebox").TNumber;
+    action: import("@sinclair/typebox").TString;
+    depositUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tvl: import("@sinclair/typebox").TNumber;
+    apr: import("@sinclair/typebox").TNumber;
+    dailyRewards: import("@sinclair/typebox").TNumber;
     aprRecord: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         cumulated: import("@sinclair/typebox").TNumber;
         timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
@@ -180,11 +185,6 @@ export declare const OpportunityWithCampaignsResourceDto: import("@sinclair/type
             aprRecordId: import("@sinclair/typebox").TString;
         }>>;
     }>>;
-    action: import("@sinclair/typebox").TString;
-    depositUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    tvl: import("@sinclair/typebox").TNumber;
-    apr: import("@sinclair/typebox").TNumber;
-    dailyRewards: import("@sinclair/typebox").TNumber;
     tvlRecord: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         total: import("@sinclair/typebox").TNumber;
         timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;