@merkl/api 0.20.42 → 0.20.43

package/dist/src/engine/dynamicData/implementations/Erc20.js

@@ -9,7 +9,7 @@ import { TokenRepository } from "@/modules/v4/token/token.repository";
 import { TokenService } from "@/modules/v4/token/token.service";
 import { log } from "@/utils/logger";
 import { Pricer } from "@/utils/pricer";
-import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
+import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, ChainId, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
 export class Erc20DynamicData {
     async build(chainId, campaigns) {
         const pricer = await Pricer.load();
@@ -126,7 +126,7 @@ export class Erc20DynamicData {
                 log.warn(`failed to update target token price: ${e}`);
             }
             i += callsForCampaign;
-            const whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
+            let whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
             const totalSupplyTargetToken = whitelistedSupplyTargetToken;
             const priceTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
             let lastEligibilityRatio = 1;
@@ -158,6 +158,9 @@ export class Erc20DynamicData {
             ]);
             const rewardToken = rewardTokens[0];
             apr = rewardToken.isPoint ? apr / 365 / 100 : apr;
+            if (campaign.chainId === ChainId.ETHERLINK) {
+                whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply;
+            }
             dynamicData.push({
                 ...campaign,
                 apr,

package/dist/src/engine/dynamicData/implementations/EventBased.js

@@ -10,7 +10,7 @@ import { Pricer } from "../../../utils/pricer";
  * @dev important: using the most recent state save with current prices
  *      it's only an estimate
  */
-async function computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaignID, priceCurrency, decimalsCurrency) {
+async function computeEventBasedPoolRewardsFromMostRecentStateSave(chainId, campaignID, priceCurrency, decimalsCurrency) {
     let stateSave;
     let blockNumber;
     let states = {};
@@ -37,23 +37,22 @@ async function computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaign
     }
     const { fileName, bucketName } = states;
     // Bucket service
-    let tvl = 0;
+    let distributedRewards = 0;
     if (!fileName || !bucketName) {
-        return { tvl, blockNumber: blockNumber };
+        return { distributedRewards, blockNumber: blockNumber };
     }
     try {
         const bucket = new BucketService("merkl-production-states", "merkl-production");
         const storedStates = JSON.parse(await bucket.pull(fileName));
         for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
-            tvl += BN2Number(value.allTimeValue, 18 - decimalsCurrency);
+            distributedRewards += BN2Number(value.allTimeValue, 18);
         }
-        tvl = tvl * priceCurrency;
-        tvl = Math.max(tvl, 1);
+        distributedRewards = Math.max(distributedRewards, 1);
     }
     catch {
         log.warn(`merklDynamic data - failed to decode state of event based on ${NETWORK_LABELS[chainId]}`);
     }
-    return { tvl, blockNumber: blockNumber };
+    return { distributedRewards, blockNumber: blockNumber };
 }
 export class EventBasedDynamicData {
     async build(chainId, campaigns) {
@@ -67,7 +66,7 @@ export class EventBasedDynamicData {
                     chainId: chainId,
                     symbol: symbolCurrency0,
                 }));
-                const { tvl } = await computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaign.campaignId, priceToken, decimalsCurrency0);
+                const { distributedRewards } = await computeEventBasedPoolRewardsFromMostRecentStateSave(chainId, campaign.campaignId, priceToken, decimalsCurrency0);
                 const c = campaign;
                 const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
                 const multiplier = BN2Number(c.campaignParameters.topicToData[0].multiplier, 12 + 9);
@@ -76,11 +75,12 @@ export class EventBasedDynamicData {
                 const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
                 let distributionMeanAPR = 0;
                 const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                const tvl = distributedRewards / multiplier;
                 if (isLive) {
                     /** Yearly rewards in $ */
                     const fixRewardRate = multiplier * priceRewardToken;
                     distributionMeanAPR = fixRewardRate;
-                    if (tvl * fixRewardRate > (amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp)) {
+                    if (distributedRewards > (amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp)) {
                         distributionMeanAPR =
                             (fixRewardRate * amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp) / tvl;
                     }

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

@@ -279,9 +279,13 @@ export class CampaignService {
      */
     static format(campaign) {
         const { DistributionChain, ComputeChain, Creator, RewardToken, params, CampaignStatus, createdAt, manualOverrides: _, ...c } = campaign;
+        const updatedParams = params;
+        if (ComputeChain.name === "Etherlink") {
+            updatedParams.blacklist = [];
+        }
         return {
             ...c,
-            params: params,
+            params: updatedParams,
             chain: ComputeChain,
             endTimestamp: Number(c.endTimestamp),
             startTimestamp: Number(c.startTimestamp),

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

@@ -16,7 +16,8 @@ export declare class ProgramPayloadService {
         safePayload: safePayload;
         nonEncodedConfig: any;
     }>;
-    static checkMinimumAmount(rewardToken: string, args: CampaignParametersStruct, distributionChainId: ChainId): Promise<boolean>;
+    static checkMinimumAmount(rewardToken: string, tokenAmount: bigint, numberOfHours: bigint, distributionChainId: ChainId): Promise<boolean>;
+    static getMinimumAmount(rewardToken: string, distributionChainId: ChainId): Promise<bigint>;
     static createSafePayloadForCampaign(args: CampaignParametersStruct, distributionChainId: ChainId, rewardToken: string, distributionCreator: string, withApproval?: boolean): Promise<[approvalTransaction, createCampaignTransaction] | [createCampaignTransaction]>;
     static initiateSafePayload(distributionChainId: ChainId, distributionCreator: string, rewardToken: string, approvalAmount?: string): safePayload;
     static buildPayload(query: CampaignPayloadInputModel, initialCampaignPayload?: safePayload | null, totalAmount?: string): Promise<safePayload>;

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

@@ -71,6 +71,11 @@ export class ProgramPayloadService {
         // Small hack to avoid the need to parse the config again
         const args = buildCampaignPayload(parsedConfig, distributionChainId).args;
         const safePayload = ProgramPayloadService.initiateSafePayload(distributionChainId, distributionCreator, rewardToken);
+        const tokenAmount = BigInt(args?.amount.toString());
+        const numberOfHours = BigInt(args?.duration.toString()) / 3600n;
+        if (!(await ProgramPayloadService.checkMinimumAmount(rewardToken, tokenAmount, numberOfHours, distributionChainId))) {
+            throw new Error("Amount is less than minimum");
+        }
         const transactions = await ProgramPayloadService.createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator ?? NULL_ADDRESS);
         safePayload.transactions.push(...transactions);
         if (debug) {
@@ -78,23 +83,25 @@ export class ProgramPayloadService {
         }
         return safePayload;
     }
-    static async checkMinimumAmount(rewardToken, args, distributionChainId) {
+    static async checkMinimumAmount(rewardToken, tokenAmount, numberOfHours, distributionChainId) {
+        const minimumAmountPerHour = await ProgramPayloadService.getMinimumAmount(rewardToken, distributionChainId);
+        if (!minimumAmountPerHour) {
+            throw new Error("Token not found");
+        }
+        return tokenAmount / numberOfHours >= BigInt(minimumAmountPerHour);
+    }
+    static async getMinimumAmount(rewardToken, distributionChainId) {
         const tokenList = await TokenService.getValidRewardTokens(distributionChainId);
         const minimumAmountPerHour = tokenList.find(token => token.address.toLowerCase() === rewardToken.toLowerCase())?.minimumAmountPerHour;
         if (!minimumAmountPerHour) {
             throw new Error("Token not found");
         }
-        const tokenAmount = BigInt(args?.amount.toString());
-        const numberOfHours = BigInt(args?.duration.toString()) / 3600n;
-        return tokenAmount / numberOfHours >= BigInt(minimumAmountPerHour);
+        return BigInt(minimumAmountPerHour);
     }
     static async createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator, withApproval = true) {
         const safePayload = _.cloneDeep(safeTemplate);
         safePayload.chainId = distributionChainId.toString();
         safePayload.createdAt = Math.floor(Date.now() / 1000);
-        if (!(await ProgramPayloadService.checkMinimumAmount(rewardToken, args, distributionChainId))) {
-            throw new Error("Amount is less than minimum");
-        }
         safePayload.transactions[0].to = rewardToken;
         safePayload.transactions[0].contractInputsValues = {
             amount: args?.amount.toString(),
@@ -180,9 +187,16 @@ export class ProgramPayloadService {
     static async buildProgramPayloadWithAmounts(query, body) {
         let campaignPayloads = null;
         const totalAmount = Object.values(body).reduce((sum, amount) => sum + BigInt(amount), 0n);
+        const minimumAmountPerHour = await ProgramPayloadService.getMinimumAmount(query.rewardToken, query.distributionChainId);
+        const numberOfHours = (BigInt(query.endTimestamp) - BigInt(query.startTimestamp)) / 3600n;
+        if (!minimumAmountPerHour) {
+            throw new Error("Token not found");
+        }
         for (const [campaign, amount] of Object.entries(body)) {
             if (Object.keys(MerklInterfaceCampaigns[query.program]).includes(campaign)) {
                 const queryCampaign = { ...query, campaign, amount: amount };
+                if (BigInt(amount) / numberOfHours < BigInt(minimumAmountPerHour))
+                    throw new Error("Amount is less than minimum");
                 campaignPayloads = await ProgramPayloadService.buildPayload(queryCampaign, campaignPayloads, totalAmount.toString());
             }
             else {