@merkl/api 0.20.99 → 0.20.101

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

@@ -2,7 +2,6 @@ import { TokenService } from "@/modules/v4/token/token.service";
 import { decodeCall } from "@/utils/decodeCalls";
 import { createCall } from "@/utils/encodeCalls";
 import { generateCardName } from "@/utils/generateCardName";
-import { generateIcons } from "@/utils/generateIcons";
 import { BN2Number } from "@sdk";
 import { tokenTypeToProtocolAndAction } from "./helpers/tokenType";
 export var Round;
@@ -186,7 +185,6 @@ export class GenericProcessor {
                 calls: [],
                 typeInfo: {
                     ...outputInfo,
-                    icons: generateIcons(type, typeInfo, campaign),
                 },
             });
         }
@@ -195,7 +193,6 @@ export class GenericProcessor {
             calls: [],
             typeInfo: {
                 ...outputInfo,
-                icons: generateIcons(type, typeInfo, campaign),
             },
         };
     }

package/dist/src/modules/v4/campaign/campaign.test.controller.js

@@ -54,7 +54,7 @@ export const CampaignTestController = new Elysia({
     // @dev Starts from the engine db to debug opportunity creation failing and preventing the api db to be filled
     .post("/metadata", async ({ body }) => {
     const engineCampaign = CampaignService.createFakeCampaignEngine(body);
-    return await OpportunityService.createFromCampaign(engineCampaign, false, false);
+    return await OpportunityService.createFromCampaign(engineCampaign, false, true);
 }, {
     body: CampaignConfigMinimal,
 })
@@ -69,7 +69,7 @@ export const CampaignTestController = new Elysia({
     ]);
     if (!engineCampaigns.length)
         throw new NotFoundError("CampaignEnum not found in engine db");
-    return await OpportunityService.createFromCampaign(engineCampaigns[0], false, false);
+    return await OpportunityService.createFromCampaign(engineCampaigns[0], false, true);
 }, {
     query: CampaignUniqueDto,
 }));

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

@@ -78,13 +78,13 @@ export class DynamicDataService {
                         const dailyAmount = isWithinTimespan ? BigInt(record.campaign.amount) / BigInt(dayspan) : BigInt(0);
                         let token;
                         try {
-                            token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
+                            token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId: record.campaign.chainId });
                         }
                         catch {
-                            await TokenService.findManyOrCreate([{ address: rewardToken, chainId }]);
-                            token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
+                            await TokenService.findManyOrCreate([{ address: rewardToken, chainId: record.campaign.chainId }]);
+                            token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId: record.campaign.chainId });
                         }
-                        const campaignDailyValue = await TokenService.getValueByTokenId(TokenService.hashId({ address: rewardToken, chainId }), dailyAmount);
+                        const campaignDailyValue = await TokenService.getValueByTokenId(TokenService.hashId({ address: rewardToken, chainId: record.campaign.chainId }), dailyAmount);
                         dailyRewards.total += campaignDailyValue;
                         if (campaignDailyValue > 0) {
                             dailyRewards.breakdowns.push({
@@ -106,6 +106,8 @@ export class DynamicDataService {
                         else {
                             aprCampaignValue = (campaignDailyValue * 365 * 100) / record.tvl;
                         }
+                        if (aprCampaignValue === Number.POSITIVE_INFINITY)
+                            aprCampaignValue = 10_001;
                         if (aprCampaignValue > 0) {
                             apr.cumulated += aprCampaignValue;
                             apr.breakdowns.push({
@@ -116,7 +118,7 @@ export class DynamicDataService {
                         }
                     }
                     catch (_err) {
-                        log.warn(`token ${rewardToken} not found`);
+                        log.error("failed to calculate daily rewards", _err);
                     }
                 }
                 updates.push({

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

@@ -5,6 +5,7 @@ import { CampaignService } from "@/modules/v4/campaign";
 import { CampaignRepository } from "@/modules/v4/campaign/campaign.repository";
 import { TokenService } from "@/modules/v4/token/token.service";
 import { UserService } from "@/modules/v4/user/user.service";
+import { log } from "@/utils/logger";
 import { Status } from "@db/api";
 import { Campaign as CampaignEnum } from "@sdk";
 import moment from "moment";
@@ -55,6 +56,8 @@ export class OpportunityService {
      */
     static async createFromCampaign(campaign, upsert = false, dryRun = false) {
         const campaignType = CampaignService.getTypeFromV3(campaign.type);
+        if (dryRun)
+            log.info(`opportunity creation dry run for ${campaign.campaignId} of type ${campaignType}`);
         const metadata = await OpportunityService.#getMetadata(campaign);
         const tags = [...((await UserService.findUnique(campaign.creator))?.tags ?? []), ...(campaign?.tags ?? [])];
         const opportunityId = OpportunityService.hashId({

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

@@ -8,7 +8,7 @@ import { log } from "@/utils/logger";
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
 import { apiDbClient } from "@db";
 import { Prisma } from "@db/api";
-import { ChainInteractionService, DistributionCreatorService, NETWORK_LABELS, bigIntToNumber, } from "@sdk";
+import { ChainInteractionService, DistributionCreatorService, NETWORK_LABELS, NULL_ADDRESS, bigIntToNumber, } from "@sdk";
 import { getAddress, parseUnits } from "viem";
 import { CacheService } from "../cache";
 import { TTLPresets } from "../cache/cache.model";
@@ -77,7 +77,13 @@ export class TokenService {
         return TokenService.fetchBalances(chainId, userAddress, allTokens);
     }
     static async fetchOnChain(token) {
-        const onchainData = await TokenRepository.getTokenInfo(token);
+        const onchainData = token.address === NULL_ADDRESS
+            ? {
+                name: `${NETWORK_LABELS[token.chainId]} Native Token`,
+                symbol: `${NETWORK_LABELS[token.chainId]} Native Token`,
+                decimals: 18,
+            }
+            : await TokenRepository.getTokenInfo(token);
         try {
             // biome-ignore lint/suspicious/noControlCharactersInRegex: <explanation>
             onchainData.name = Buffer.from(onchainData.name.replace(/\u0000/g, ""), "utf-8").toString("utf-8");
@@ -234,15 +240,18 @@ export class TokenService {
                 return await TokenRepository.findUniqueOrThrow(id);
             }
             catch (err) {
-                if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2025") {
-                    return TokenService.format(await TokenService.fillAndCreate({
-                        ...token,
-                        verified: false,
-                        icon: "",
-                    }));
+                try {
+                    if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2025") {
+                        return TokenService.format(await TokenService.fillAndCreate({
+                            ...token,
+                            verified: false,
+                            icon: "",
+                        }));
+                    }
                 }
+                catch { }
+                throw new HttpError(`Failed to fetch or create token ${token.address} on chain ${token.chainId}.`);
             }
-            throw new HttpError(`Failed to fetch or create token ${token.address} on chain ${token.chainId}.`);
         }));
     }
     static async getValidRewardTokens(chainId) {