@merkl/api 0.20.64 → 0.20.65

package/dist/src/engine/erc20SubTypeProcessors/implementations/curveNPoolProcessor.d.ts

@@ -1,12 +1,13 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import type { tokenType } from "../constants";
+import type { tokenTypeStruct } from "../interface";
 type callType = {
     key: keyof dataRawCurveN;
     call: string;
     target: keyof callKeysCurveN;
-    metaData?: keyof callKeysCurveN | string;
+    callArgs?: keyof callKeysCurveN | string;
     optional?: boolean;
 };
 type callKeysCurveN = mandatoryCallKeys & {

package/dist/src/engine/erc20SubTypeProcessors/implementations/curveNPoolProcessor.js

@@ -12,13 +12,12 @@ export class CurveNPoolProcessor extends GenericProcessor {
         round3: [],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
-    // override computeRound1(): void {}
     processingRound2(typeInfo) {
         typeInfo.numberTokens = Number(typeInfo.numberTokens);
         for (let i = 0; i < typeInfo.numberTokens; i++) {
             typeInfo[`${i}`] = i.toString();
             this.rounds.round2 = this.rounds.round2.concat([
-                { key: `token${i}`, call: "coins", target: "tokenAddress", metaData: i.toString() },
+                { key: `token${i}`, call: "coins", target: "tokenAddress", callArgs: i.toString() },
             ]);
         }
     }
@@ -27,14 +26,14 @@ export class CurveNPoolProcessor extends GenericProcessor {
             this.rounds.round3 = this.rounds.round3.concat([
                 { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
                 { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
-                { key: `balanceToken${i}`, call: "balances", target: "tokenAddress", metaData: i.toString() },
+                { key: `balanceToken${i}`, call: "balances", target: "tokenAddress", callArgs: i.toString() },
             ]);
         }
     }
     computeRound3(index, type, typeInfo, calls) {
         for (let i = 0; i < typeInfo.numberTokens; i++) {
             this.rounds.round2 = this.rounds.round2.concat([
-                { key: `token${i}`, call: "coins", target: "tokenAddress", metaData: i.toString() },
+                { key: `token${i}`, call: "coins", target: "tokenAddress", callArgs: i.toString() },
             ]);
         }
         return super.computeRound3(index, type, typeInfo, calls);
@@ -44,7 +43,7 @@ export class CurveNPoolProcessor extends GenericProcessor {
             this.rounds.round3 = this.rounds.round3.concat([
                 { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
                 { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
-                { key: `balanceToken${i}`, call: "balances", target: "tokenAddress", metaData: i.toString() },
+                { key: `balanceToken${i}`, call: "balances", target: "tokenAddress", callArgs: i.toString() },
             ]);
         }
         return super.computeRound4(index, type, typeInfo, calls, campaign);
@@ -91,7 +90,7 @@ export class CurveNPoolProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
+            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
             tokensDisplay,
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/implementations/curveProcessor.d.ts

@@ -1,12 +1,11 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
+import { tokenType } from "../constants";
 type callType = {
     key: keyof dataRawCurve;
     call: string;
     target: keyof callKeysCurve;
-    metaData?: keyof callKeysCurve;
     optional?: boolean;
 };
 type callKeysCurve = mandatoryCallKeys & {

package/dist/src/engine/erc20SubTypeProcessors/implementations/curveProcessor.js

@@ -1,7 +1,7 @@
 import { generateCardName } from "@/utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { GenericProcessor } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
+import { tokenType } from "../constants";
 export class CurveProcessor extends GenericProcessor {
     rounds = {
         round1: [
@@ -18,7 +18,6 @@ export class CurveProcessor extends GenericProcessor {
         round3: [],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
-    // override computeRound1(): void {}
     async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const lp_price = BN2Number(typeInfo.lp_price, 18);
@@ -74,7 +73,7 @@ export class CurveProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
+            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
             tokensDisplay,
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/implementations/stakedCurveProcessor.d.ts

@@ -1,12 +1,12 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
+import { tokenType } from "../constants";
 type callType = {
     key: keyof dataRawStakedCurve;
     call: string;
     target: keyof callKeysStakedCurve;
-    metaData?: keyof callKeysStakedCurve;
+    callArgs?: keyof callKeysStakedCurve;
     optional?: boolean;
 };
 type callKeysStakedCurve = mandatoryCallKeys & {

package/dist/src/engine/erc20SubTypeProcessors/implementations/stakedCurveProcessor.js

@@ -2,7 +2,7 @@ import { generateCardName } from "@/utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { BigNumber } from "ethers";
 import { GenericProcessor } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
+import { tokenType } from "../constants";
 export class StakedCurveProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
@@ -19,11 +19,10 @@ export class StakedCurveProcessor extends GenericProcessor {
             { key: "symbolToken2", call: "symbol", target: "token2", optional: true },
         ],
         round4: [
-            { key: "toAssets", call: "convertToAssets", target: "tokenAddress", metaData: "amount" },
+            { key: "toAssets", call: "convertToAssets", target: "tokenAddress", callArgs: "amount" },
             { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
         ],
     };
-    // override computeRound1(): void {}
     processingRound3(typeInfo) {
         typeInfo.amount = BigNumber.from(10).pow(18).toString();
     }
@@ -81,7 +80,7 @@ export class StakedCurveProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
+            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
             tokensDisplay,
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/implementations/xU308Processor.d.ts

@@ -1,12 +1,12 @@
 import type { Pricer } from "@/utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType } from "../helpers/tokenType";
+import type { tokenType } from "../constants";
 type callType = {
     key: keyof dataRawxU308;
     call: string;
     target: keyof callKeysxU308;
-    metaData?: keyof callKeysxU308;
+    callArgs?: keyof callKeysxU308;
 };
 type callKeysxU308 = mandatoryCallKeys & {
     pool: string;

package/dist/src/engine/erc20SubTypeProcessors/implementations/xU308Processor.js

@@ -13,12 +13,11 @@ export class xU308Processor extends GenericProcessor {
             { key: "symbolToken1", call: "symbol", target: "_token1" },
             { key: "decimalsToken0", call: "decimals", target: "_token0" },
             { key: "decimalsToken1", call: "decimals", target: "_token1" },
-            { key: "balanceToken0", call: "balanceOf", target: "_token0", metaData: "pool" },
-            { key: "balanceToken1", call: "balanceOf", target: "_token1", metaData: "pool" },
+            { key: "balanceToken0", call: "balanceOf", target: "_token0", callArgs: "pool" },
+            { key: "balanceToken1", call: "balanceOf", target: "_token1", callArgs: "pool" },
         ],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
-    // override computeRound1(): void {}
     processingRound2(typeInfo) {
         typeInfo.pool = "0xB387D0A73619791420De4a1e5e710023Cb0f49c0";
     }
@@ -35,7 +34,7 @@ export class xU308Processor extends GenericProcessor {
             blacklistedSupply,
             priceTargetToken,
             totalSupply,
-            cardName: generateCardName(type, typeInfo, campaign),
+            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
             tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound1.d.ts

@@ -1,3 +1,17 @@
-import type { Campaign, CampaignParameters, ResultDto } from "@sdk";
-import { type tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound1(calls: ResultDto[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;
+import type { CampaignParameters } from "@sdk";
+import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
+import { tokenType } from "./constants";
+declare function generateResult(type: tokenType, name: string, campaign: CampaignParameters<ERC20SupportedCampaignType>, data?: {
+    owner?: string;
+    factory?: string;
+    fundValueCalculator?: string;
+    dispatcher?: string;
+}): import("./interface").tokenTypeStruct;
+export declare function parseForStaking(campaign: CampaignParameters<ERC20SupportedCampaignType>): {
+    isStaking: false;
+} | {
+    isStaking: true;
+    stakingContract: string;
+};
+export declare function getTokenTypeRound1(callResults: string[], index: number, campaign: CampaignParameters<ERC20SupportedCampaignType>): ReturnType<typeof generateResult>;
+export {};

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

@@ -1,9 +1,9 @@
 import { decodeCall, decodeReturnValue } from "@/utils/decodeCalls";
+import { tokenType } from "./constants";
+import { erc20ProcessorFactory } from "./factory";
 import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
 import { getTypeFromAddressChain } from "./helpers/hardcoded";
 import { getTypeFromOwnerAddress } from "./helpers/ownerFinder";
-import { tokenType } from "./helpers/tokenType";
-import { processorMapping } from "./implementations/processorMapping";
 function satisfiesNameConditions(name, type) {
     const lowerCaseName = name.toLowerCase();
     switch (type) {
@@ -165,178 +165,168 @@ function satisfiesNameConditions(name, type) {
             return false;
     }
 }
-function generateResult(type, name, targetToken, typeInfo, campaign) {
-    const ProcessorClass = processorMapping[type];
-    if (!ProcessorClass) {
-        throw new Error(`Processor not found for key: ${type}`);
-    }
-    const processorObject = new ProcessorClass();
-    if (campaign)
-        typeInfo = { ...typeInfo, ...parseForStaking(campaign) };
-    typeInfo = {
-        ...typeInfo,
+function generateResult(type, name, campaign, data) {
+    const typeInfo = {
         name: name,
-        tokenAddress: targetToken,
+        tokenAddress: campaign.campaignParameters.targetToken,
         totalSupply: 0,
         blacklistedSupply: 0,
+        whitelistedSupply: 0,
+        ...parseForStaking(campaign),
+        ...(data ?? {}),
     };
-    return processorObject.computeRound1(type, typeInfo);
+    return erc20ProcessorFactory(type, campaign).computeRound1(typeInfo); // TODO Fix
 }
-function processNamingConditions(type, name, targetToken, campaign) {
+function processNamingConditions(type, name, campaign) {
     if (satisfiesNameConditions(name, type)) {
-        return generateResult(type, name, targetToken, {}, campaign);
+        return generateResult(type, name, campaign);
     }
 }
-function processNamingConditionsInOrder(types, name, targetToken, campaign) {
+function processNamingConditionsInOrder(types, name, campaign) {
     for (const type of types) {
-        const result = processNamingConditions(type, name, targetToken, campaign);
+        const result = processNamingConditions(type, name, campaign);
         if (result)
             return result;
     }
 }
-function parseForFactory(calls, targetToken, campaign) {
+function parseForFactory(calls, campaign) {
     try {
         const factory = decodeReturnValue(calls.factory, "factory");
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromFactoryAddress(factory);
         if (type !== tokenType.unknown)
-            return generateResult(type, name, targetToken, { factory }, campaign);
+            return generateResult(type, name, campaign, { factory });
     }
     catch (e) {
         // No factory on this token
         // console.log(e);
     }
 }
-function parseForOwner(calls, targetToken) {
+function parseForOwner(calls, campaign) {
     try {
         const owner = decodeReturnValue(calls.owner, "owner");
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromOwnerAddress(owner);
         if (type !== tokenType.unknown)
-            return generateResult(type, name, targetToken, { owner: owner });
+            return generateResult(type, name, campaign, { owner });
     }
     catch (e) {
         // No factory on this token
         // console.log(e);
     }
 }
-function parseForEnzyme(calls, targetToken) {
+function parseForEnzyme(calls, campaign) {
     // Enzyme check
     try {
         const dispatcher = decodeReturnValue(calls.creator, "getCreator");
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromFactoryAddress(dispatcher);
         const fundValueCalculator = enzymeFundValueCalculatorRouterMapping[dispatcher];
-        const typeInfo = {
-            fundValueCalculator,
-            dispatcher,
-        };
         if (type === tokenType.enzyme) {
-            return generateResult(type, name, targetToken, typeInfo);
+            return generateResult(type, name, campaign, {
+                fundValueCalculator,
+                dispatcher,
+            });
         }
     }
     catch (e) {
         // No factory on this token
     }
 }
-function parseForMetamorpho(calls, targetToken) {
+function parseForMetamorpho(calls, campaign) {
     // MetaMorpho check
     try {
         decodeReturnValue(calls.metamorpho, "MORPHO");
         const name = decodeReturnValue(calls.name, "name");
-        return generateResult(tokenType.metamorpho, name, targetToken, {});
+        return generateResult(tokenType.metamorpho, name, campaign);
     }
     catch (e) {
         // Not a metamorpho token
     }
 }
-function parseForBalancer(calls, targetToken, name) {
+function parseForBalancer(calls, name, campaign) {
     // Check for balancer pools
     try {
         decodeReturnValue(calls.poolId, "getPoolId");
-        return generateResult(tokenType.balancerPool, name, targetToken, {});
+        return generateResult(tokenType.balancerPool, name, campaign);
     }
     catch (e) {
         // Not a balancer pool
     }
     try {
         decodeReturnValue(calls.vault, "getVault");
-        return generateResult(tokenType.balancerV3, name, targetToken, {});
+        return generateResult(tokenType.balancerV3, name, campaign);
     }
     catch (e) {
         // Not a balancer v3 pool
     }
 }
-function checkAgainstHardcoded(calls, chainId, targetToken) {
+function checkAgainstHardcoded(calls, campaign) {
     // Check for balancer pools
     try {
         const name = decodeReturnValue(calls.name, "name");
-        const type = getTypeFromAddressChain(chainId, targetToken);
+        const type = getTypeFromAddressChain(campaign.computeChainId, campaign.campaignParameters.targetToken);
         if (type !== tokenType.unknown)
-            return generateResult(type, name, targetToken, {});
+            return generateResult(type, name, campaign);
     }
     catch (e) {
         // Not a hardcoded address
     }
 }
-function parseForStaking(campaign) {
+export function parseForStaking(campaign) {
     try {
         const whitelist = campaign.campaignParameters.whitelist;
         if (whitelist.length === 1) {
             const forwarders = campaign.campaignParameters.forwarders;
             if (forwarders.length === 1) {
                 if (forwarders[0].sender === whitelist[0]) {
-                    return { isStaking: "true", stakingContract: whitelist[0] };
+                    return { isStaking: true, stakingContract: whitelist[0] };
                 }
             }
         }
     }
-    catch (e) {
-        // No factory on this token
-        // console.log(e);
-    }
-    return { isStaking: "false" };
+    catch { }
+    return { isStaking: false };
 }
-export function getTokenTypeRound1(calls, targetToken, index, campaign) {
-    const returnValueOfCalls = calls.map(call => call.returnData);
+export function getTokenTypeRound1(callResults, index, campaign) {
     const returnValue = {
-        factory: returnValueOfCalls[index],
-        metamorpho: returnValueOfCalls[index + 1],
-        name: returnValueOfCalls[index + 2],
-        poolId: returnValueOfCalls[index + 3],
-        creator: returnValueOfCalls[index + 4],
-        owner: returnValueOfCalls[index + 5],
-        vault: returnValueOfCalls[index + 6],
+        factory: callResults[index],
+        metamorpho: callResults[index + 1],
+        name: callResults[index + 2],
+        poolId: callResults[index + 3],
+        creator: callResults[index + 4],
+        owner: callResults[index + 5],
+        vault: callResults[index + 6],
     };
-    let result = parseForFactory(returnValue, targetToken, campaign);
+    let result = parseForFactory(returnValue, campaign);
     if (result)
         return result;
-    result = parseForOwner(returnValue, targetToken);
+    result = parseForOwner(returnValue, campaign);
     if (result)
         return result;
-    result = checkAgainstHardcoded(returnValue, campaign.computeChainId, targetToken);
+    result = checkAgainstHardcoded(returnValue, campaign);
     if (result)
         return result;
-    result = parseForEnzyme(returnValue, targetToken);
+    result = parseForEnzyme(returnValue, campaign);
     if (result)
         return result;
-    result = parseForMetamorpho(returnValue, targetToken);
+    result = parseForMetamorpho(returnValue, campaign);
     if (result)
         return result;
     let name;
     try {
-        name = decodeCall(returnValueOfCalls, index + 2, "name");
+        name = decodeCall(callResults, index + 2, "name");
     }
     catch {
-        return generateResult(tokenType.unknown, "Unknown", targetToken, {}, campaign);
+        return generateResult(tokenType.unknown, "Unknown", campaign);
     }
-    result = parseForBalancer(returnValue, targetToken, name);
+    result = parseForBalancer(returnValue, name, campaign);
     if (result)
         return result;
     // Order matters
     const ordered_token_Type = Object.values(tokenType).filter(value => typeof value === "string");
-    result = processNamingConditionsInOrder(ordered_token_Type, name, targetToken, campaign);
+    result = processNamingConditionsInOrder(ordered_token_Type, name, campaign);
     if (result)
         return result;
-    return generateResult(tokenType.unknown, name, targetToken, {}, campaign);
+    return generateResult(tokenType.unknown, name, campaign);
 }

package/dist/src/engine/opportunityMetadata/implementations/JsonAirdrop.js

@@ -19,7 +19,7 @@ export class JsonAirdropMetadata {
                 tokens: [
                     {
                         chainId: computeChainId,
-                        address: tokenAddress, // TODO: Make sure targetToken is set
+                        address: tokenAddress,
                     },
                 ],
                 mainProtocol: aavePrefix || aciPrefix ? "aave" : undefined,

package/dist/src/index.d.ts

@@ -261,20 +261,31 @@ declare const app: Elysia<"", false, {
                         response: {
                             200: {
                                 id: string;
-                                name: string;
+                                chainId: number;
                                 type: string;
-                                status: import("@db/api").$Enums.Status;
-                                tags: string[];
                                 identifier: string;
-                                action: import("@db/api").$Enums.OpportunityAction;
-                                manualOverrides: import("@db/api").$Enums.OpportunityManualOverride[];
-                                chainId: number;
-                                depositUrl: string | null;
-                                explorerAddress: string | null;
-                                mainProtocolId: string | null;
-                                tvl: number;
-                                apr: number;
-                                dailyRewards: number;
+                                name: string;
+                                status: "PAST" | "LIVE" | "SOON";
+                                action: any;
+                                tokens: ({
+                                    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;
+                                })[];
+                                mainProtocol: "splice" | "morpho" | "quickswap" | "euler" | "ambient" | "uniswap" | "arthswap" | "base-swap" | "camelot" | "crust" | "fenix" | "horiza" | "izumi" | "kim" | "pancake-swap" | "ramses" | "retro" | "stryke" | "sushi-swap" | "swapr" | "thruster" | "voltage" | "zero" | "koi" | "supswap" | "zk-swap" | "thirdtrade" | "swap-x" | "velodrome" | "aerodrome" | "balancer" | "curve" | "cross_curve" | "curveNPool" | "aura" | "akron" | "beefy" | "dragonswap" | "poolside" | "syncswap" | "neptune" | "zkSwapThreePool" | "rfx" | "ra" | "maverick" | "trader-joe" | "hanji" | "radiant" | "aave" | "fraxlend" | "ironclad" | "gearbox" | "compound" | "sturdy" | "frax" | "ionic" | "moonwell" | "fluid" | "silo" | "dolomite" | "badger" | "ajna" | "layerbank" | "ion" | "venus" | "woofi" | "reactor_fusion" | "eigenlayer" | "vest" | "zerolend" | "hyperdrive" | "gamma" | "oku" | "hourglass" | "veda" | "kyo" | "sonex" | "lendle" | "tako-tako" | "equalizer" | "spectra" | "beraborrow" | "superlend" | "avalon" | "iguana" | "xlend" | "angles" | "enzyme" | "toros" | "vicuna" | "bunni" | "beratrax" | "concrete" | "cian" | "pendle" | "yei" | "filament" | "gammaswap" | "maha" | "tempest" | "uranium" | "holdstation" | "katana" | "satlayer" | undefined;
+                                depositUrl: any;
+                                explorerAddress: string | undefined;
+                                tags: string[];
                             };
                         };
                     };

package/dist/src/jobs/update-rpc-calls-cache.js

@@ -7,11 +7,16 @@ import { log } from "@/utils/logger";
 import { NETWORK_LABELS } from "@sdk";
 const main = async () => {
     try {
-        const chains = await ChainService.getSupportedIds();
+        const chainIds = await ChainService.getSupportedIds();
         const promises = [];
-        for (const chain of chains)
-            promises.push(MerklRootRepository.fetch(chain).catch(_err => log.warn(`RPC calls cache update failed for ${NETWORK_LABELS[chain]}.`)));
-        await Promise.allSettled(promises);
+        for (const chainId of chainIds)
+            promises.push(CacheService.set(TTLPresets.HOUR_12, MerklRootRepository.fetch, chainId));
+        const results = await Promise.allSettled(promises);
+        for (const [index, result] of results.entries()) {
+            if (result.status === "rejected") {
+                log.warn(`Failed to fetch Merkl root for ${NETWORK_LABELS[chainIds[index]]}: ${result.reason}`);
+            }
+        }
         // ─── Refresh Cache For GET /opportunities ────
         await CacheService.set(TTLPresets.MIN_5, OpportunityService.findMany, { items: 25, page: 0 });
         await CacheService.set(TTLPresets.MIN_5, OpportunityService.findMany, { items: 50, page: 0 });

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

@@ -116,20 +116,31 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                     response: {
                         200: {
                             id: string;
-                            name: string;
+                            chainId: number;
                             type: string;
-                            status: import("@db/api").$Enums.Status;
-                            tags: string[];
                             identifier: string;
-                            action: import("@db/api").$Enums.OpportunityAction;
-                            manualOverrides: import("@db/api").$Enums.OpportunityManualOverride[];
-                            chainId: number;
-                            depositUrl: string | null;
-                            explorerAddress: string | null;
-                            mainProtocolId: string | null;
-                            tvl: number;
-                            apr: number;
-                            dailyRewards: number;
+                            name: string;
+                            status: "PAST" | "LIVE" | "SOON";
+                            action: any;
+                            tokens: ({
+                                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;
+                            })[];
+                            mainProtocol: "splice" | "morpho" | "quickswap" | "euler" | "ambient" | "uniswap" | "arthswap" | "base-swap" | "camelot" | "crust" | "fenix" | "horiza" | "izumi" | "kim" | "pancake-swap" | "ramses" | "retro" | "stryke" | "sushi-swap" | "swapr" | "thruster" | "voltage" | "zero" | "koi" | "supswap" | "zk-swap" | "thirdtrade" | "swap-x" | "velodrome" | "aerodrome" | "balancer" | "curve" | "cross_curve" | "curveNPool" | "aura" | "akron" | "beefy" | "dragonswap" | "poolside" | "syncswap" | "neptune" | "zkSwapThreePool" | "rfx" | "ra" | "maverick" | "trader-joe" | "hanji" | "radiant" | "aave" | "fraxlend" | "ironclad" | "gearbox" | "compound" | "sturdy" | "frax" | "ionic" | "moonwell" | "fluid" | "silo" | "dolomite" | "badger" | "ajna" | "layerbank" | "ion" | "venus" | "woofi" | "reactor_fusion" | "eigenlayer" | "vest" | "zerolend" | "hyperdrive" | "gamma" | "oku" | "hourglass" | "veda" | "kyo" | "sonex" | "lendle" | "tako-tako" | "equalizer" | "spectra" | "beraborrow" | "superlend" | "avalon" | "iguana" | "xlend" | "angles" | "enzyme" | "toros" | "vicuna" | "bunni" | "beratrax" | "concrete" | "cian" | "pendle" | "yei" | "filament" | "gammaswap" | "maha" | "tempest" | "uranium" | "holdstation" | "katana" | "satlayer" | undefined;
+                            depositUrl: any;
+                            explorerAddress: string | undefined;
+                            tags: string[];
                         };
                     };
                 };

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

@@ -25,20 +25,31 @@ export declare abstract class OpportunityService {
     }>;
     static deleteOverrides(id: string, overridesToDelete: OpportunityManualOverride[]): Promise<{
         id: string;
-        name: string;
+        chainId: number;
         type: string;
-        status: import("@db/api").$Enums.Status;
-        tags: string[];
         identifier: string;
-        action: import("@db/api").$Enums.OpportunityAction;
-        manualOverrides: import("@db/api").$Enums.OpportunityManualOverride[];
-        chainId: number;
-        depositUrl: string | null;
-        explorerAddress: string | null;
-        mainProtocolId: string | null;
-        tvl: number;
-        apr: number;
-        dailyRewards: number;
+        name: string;
+        status: "PAST" | "LIVE" | "SOON";
+        action: OpportunityAction;
+        tokens: ({
+            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;
+        })[];
+        mainProtocol: "splice" | "morpho" | "quickswap" | "euler" | "ambient" | "uniswap" | "arthswap" | "base-swap" | "camelot" | "crust" | "fenix" | "horiza" | "izumi" | "kim" | "pancake-swap" | "ramses" | "retro" | "stryke" | "sushi-swap" | "swapr" | "thruster" | "voltage" | "zero" | "koi" | "supswap" | "zk-swap" | "thirdtrade" | "swap-x" | "velodrome" | "aerodrome" | "balancer" | "curve" | "cross_curve" | "curveNPool" | "aura" | "akron" | "beefy" | "dragonswap" | "poolside" | "syncswap" | "neptune" | "zkSwapThreePool" | "rfx" | "ra" | "maverick" | "trader-joe" | "hanji" | "radiant" | "aave" | "fraxlend" | "ironclad" | "gearbox" | "compound" | "sturdy" | "frax" | "ionic" | "moonwell" | "fluid" | "silo" | "dolomite" | "badger" | "ajna" | "layerbank" | "ion" | "venus" | "woofi" | "reactor_fusion" | "eigenlayer" | "vest" | "zerolend" | "hyperdrive" | "gamma" | "oku" | "hourglass" | "veda" | "kyo" | "sonex" | "lendle" | "tako-tako" | "equalizer" | "spectra" | "beraborrow" | "superlend" | "avalon" | "iguana" | "xlend" | "angles" | "enzyme" | "toros" | "vicuna" | "bunni" | "beratrax" | "concrete" | "cian" | "pendle" | "yei" | "filament" | "gammaswap" | "maha" | "tempest" | "uranium" | "holdstation" | "katana" | "satlayer" | undefined;
+        depositUrl: any;
+        explorerAddress: string | undefined;
+        tags: string[];
     }>;
     /**
      * create an opportunity without campaigns