@merkl/api 0.20.34 → 0.20.36

package/dist/src/engine/opportunityMetadata/implementations/Radiant.d.ts

@@ -1,5 +1,5 @@
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
 import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.RADIANT;
 export declare class RadiantMetadata implements MetadataBuilder<campaignType> {

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

@@ -1,11 +1,28 @@
+import { log } from "@/utils/logger";
 import { OpportunityAction } from "@db/api";
+import { ChainInteractionService, NETWORK_LABELS, RadiantInterface, } from "@sdk";
 import { getAddress } from "viem";
 export class RadiantMetadata {
     async build(computeChainId, params, subType) {
+        const tokens = [{ chainId: computeChainId, address: params.targetToken }];
+        try {
+            const result = await ChainInteractionService(computeChainId).fetchState([
+                {
+                    target: params.targetToken,
+                    allowFailure: true,
+                    callData: RadiantInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
+                },
+            ]);
+            const underlyingAddress = getAddress(RadiantInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", result[0].returnData)[0]);
+            tokens.push({ chainId: computeChainId, address: underlyingAddress });
+        }
+        catch {
+            log.warn(`failed to fetch underlying asset address on ${NETWORK_LABELS[computeChainId]} for radiant token ${params.targetToken}`);
+        }
         return {
             action: subType <= 1 ? OpportunityAction.LEND : OpportunityAction.BORROW,
             name: [subType <= 1 ? "Lend" : "Borrow", params.symbolTargetToken].join(" "),
-            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            tokens,
             mainProtocol: "radiant",
             explorerAddress: getAddress(params.targetToken),
         };

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

@@ -6,8 +6,10 @@ export class ChainService {
     static async get(chainId) {
         return ChainRepository.read(chainId);
     }
-    //TODO: determine find vs get nomenclature and cache handling
     static async findMany(query) {
+        // Bypass cache in test mode
+        if (query.test)
+            return ChainRepository.findMany(query);
         return await CacheService.wrap(TTLPresets.MIN_10, ChainRepository.findMany, query);
     }
     static async countMany(query) {

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

@@ -166,9 +166,11 @@ export class OpportunityService {
      * @returns A list of opportunities
      */
     static async findMany(query) {
+        // Bypass cache in test mode
+        if (query.test)
+            return (await OpportunityRepository.findMany(query)).map(c => OpportunityService.formatResponse(c));
         return await CacheService.wrap(TTLPresets.MIN_5, async (query) => {
-            const opportunities = await OpportunityRepository.findMany(query);
-            return opportunities.map(c => OpportunityService.formatResponse(c));
+            return (await OpportunityRepository.findMany(query)).map(c => OpportunityService.formatResponse(c));
         }, query);
     }
     /**

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

@@ -1,5 +1,6 @@
 import type { CreateProtocolModel, GetProtocolsQueryModel, Protocol, ProtocolId, UpdateProtocolModel } from "./protocol.model";
 export declare abstract class ProtocolService {
+    #private;
     static findMany(query: GetProtocolsQueryModel): Promise<Protocol["model"][]>;
     static countMany(query: GetProtocolsQueryModel): Promise<number>;
     static getFromId(id: ProtocolId | string): Promise<Protocol["model"] | null>;

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

@@ -6,17 +6,20 @@ import { TTLPresets } from "../cache/cache.model";
 import { ProtocolRepository } from "./protocol.repository";
 // ─── Protocols Services ──────────────────────────────────────────────────────
 export class ProtocolService {
+    static async #findMany(query) {
+        const protocols = await ProtocolRepository.findMany(query);
+        const enrichedProtocols = protocols.map(({ MainOpportunities, ...protocol }) => ({
+            ...protocol,
+            dailyRewards: MainOpportunities.reduce((sum, opportunity) => sum + opportunity.dailyRewards, 0),
+            numberOfLiveCampaigns: MainOpportunities.reduce((sum, opportunity) => sum + opportunity.Campaigns.length, 0),
+            opportunityLiveTags: [...new Set(MainOpportunities.flatMap(opportunity => opportunity.action))], // ensure uniqness of tags
+        }));
+        return enrichedProtocols;
+    }
     static async findMany(query) {
-        return await CacheService.wrap(TTLPresets.MIN_10, async (query) => {
-            const protocols = await ProtocolRepository.findMany(query);
-            const enrichedProtocols = protocols.map(({ MainOpportunities, ...protocol }) => ({
-                ...protocol,
-                dailyRewards: MainOpportunities.reduce((sum, opportunity) => sum + opportunity.dailyRewards, 0),
-                numberOfLiveCampaigns: MainOpportunities.reduce((sum, opportunity) => sum + opportunity.Campaigns.length, 0),
-                opportunityLiveTags: [...new Set(MainOpportunities.flatMap(opportunity => opportunity.action))], // ensure uniqness of tags
-            }));
-            return enrichedProtocols;
-        }, query);
+        if (query.test)
+            return await ProtocolRepository.findMany(query);
+        return await CacheService.wrap(TTLPresets.MIN_10, ProtocolService.#findMany, query);
     }
     static async countMany(query) {
         return ProtocolRepository.countMany(query);

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

@@ -8,8 +8,6 @@ import { Prisma } from "@db/api";
 import { ChainInteractionService, DistributionCreatorService, NETWORK_LABELS, bigIntToNumber, } from "@sdk";
 import { getAddress, parseUnits } from "viem";
 import { BucketService } from "../bucket/bucket.service";
-import { CacheService } from "../cache";
-import { TTLPresets } from "../cache/cache.model";
 import { IconService } from "../icon/icon.service";
 import { PriceService } from "../price";
 import { TokenRepository } from "./token.repository";
@@ -272,17 +270,15 @@ export class TokenService {
         }));
     }
     static async getValidRewardTokens(chainId) {
-        return await CacheService.wrap(TTLPresets.MIN_5, async (chainId) => {
-            const validRewardTokens = await DistributionCreatorService(chainId).validRewardTokens();
-            return (await TokenRepository.findList(chainId, validRewardTokens.map(t => getAddress(t.token)))).map(x => {
-                return {
-                    ...x,
-                    minimumAmountPerHour: validRewardTokens
-                        .find(t => getAddress(t.token) === x.address)
-                        ?.minimumAmountPerEpoch.toString(),
-                };
-            });
-        }, chainId);
+        const validRewardTokens = await DistributionCreatorService(chainId).validRewardTokens();
+        return (await TokenRepository.findList(chainId, validRewardTokens.map(t => getAddress(t.token)))).map(x => {
+            return {
+                ...x,
+                minimumAmountPerHour: validRewardTokens
+                    .find(t => getAddress(t.token) === x.address)
+                    ?.minimumAmountPerEpoch.toString(),
+            };
+        });
     }
     static async update(id, data) {
         return await TokenRepository.update(id, data);