@merkl/api 0.17.24 → 0.17.26

package/dist/src/libs/campaigns/campaignTypes/EventBasedDynamicData.d.ts

@@ -0,0 +1,3 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export declare function EventBasedDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.EVENT_BASED>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.EVENT_BASED>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/EventBasedDynamicData.js

@@ -0,0 +1,117 @@
+import { BucketService } from "../../../modules/v4/bucket/bucket.service";
+import { engineDbClient } from "../../../utils/prisma";
+import { BN2Number, ChainInteractionService, NETWORK_LABELS, } from "@sdk";
+import moment from "moment";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+// Constants
+const CALLS_LENGTH = 2;
+/**
+ * Compute TVL
+ * @dev important: using the most recent state save with current prices
+ *      it's only an estimate
+ */
+async function computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaignID, priceCurrency, decimalsCurrency) {
+    let stateSave;
+    let blockNumber;
+    let states = {};
+    try {
+        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
+        const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
+            where: {
+                id: `EventBasedProcessor_${chainId}_${campaignID}`,
+                blockNumber: {
+                    lte: currentBlock,
+                },
+            },
+            orderBy: {
+                blockNumber: "desc",
+            },
+        });
+        stateSave = mostRecentStateSave.state;
+        blockNumber = mostRecentStateSave?.blockNumber;
+        states = stateSave.states;
+        // const globalState = stateSave.globalState as { tick: number; liquidity: string };
+    }
+    catch (e) {
+        log.warn(`merklDynamic data - failed to read a recent state of ${campaignID} on ${NETWORK_LABELS[chainId]}`);
+    }
+    const { fileName, bucketName } = states;
+    // Bucket service
+    let tvl = 0;
+    try {
+        const bucket = new BucketService(bucketName, "merkl-production");
+        const storedStates = JSON.parse(await bucket.pull(fileName));
+        for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
+            tvl += priceCurrency * BN2Number(value.allTimeValue, decimalsCurrency);
+        }
+    }
+    catch (e) {
+        console.log(e);
+        log.warn(`merklDynamic data - failed to decode state of event based on ${NETWORK_LABELS[chainId]}`);
+    }
+    return { tvl, blockNumber: blockNumber };
+}
+export async function EventBasedDynamicData(chainId, campaigns) {
+    const dynamicData = [];
+    const pricer = await Pricer.load();
+    const calls = [];
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                for (const campaign of campaigns) {
+                    try {
+                        const decimalsCurrency0 = 6;
+                        const symbolCurrency0 = "USDC";
+                        const priceToken = (await pricer.get({
+                            chainId: chainId,
+                            symbol: symbolCurrency0,
+                        }));
+                        const { tvl, blockNumber } = await computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaign.campaignId, priceToken, decimalsCurrency0);
+                        const c = campaign;
+                        const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
+                        const multiplier = BN2Number(c.campaignParameters.topicToData[0].multiplier, 9);
+                        const startTimestamp = BN2Number(c.startTimestamp, 0);
+                        const endTimestamp = BN2Number(c.endTimestamp, 0);
+                        const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
+                        let distributionMeanAPR = 0;
+                        const priceRewardToken = 1;
+                        if (isLive && c.campaignParameters.symbolRewardToken !== "aglaMerkl") {
+                            /**
+                             * Handle whitelisted/blacklisted addresses to compute APR
+                             */
+                            if (c.campaignParameters.whitelist.length > 0) {
+                                // TODO
+                            }
+                            else if (c.campaignParameters.blacklist.length > 0) {
+                                // TODO
+                            }
+                            /** Yearly rewards in $ */
+                            const yearlyTokenRewards = (multiplier * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
+                            distributionMeanAPR = yearlyTokenRewards / tvl;
+                            distributionMeanAPR = !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
+                            dynamicData.push({
+                                ...campaign,
+                                apr: distributionMeanAPR,
+                                priceRewardToken: priceRewardToken,
+                                tvl: tvl,
+                            });
+                        }
+                    }
+                    catch (e) {
+                        dynamicData.push({
+                            ...campaign,
+                            apr: 0,
+                            priceRewardToken: 0,
+                            tvl: 1,
+                        });
+                    }
+                }
+                return dynamicData;
+            },
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignsDynamicData.js

@@ -10,6 +10,7 @@ import { ERC20DynamicData } from "./campaignTypes/ERC20DynamicData";
 import { ERC20_SNAPSHOTDynamicData } from "./campaignTypes/ERC20_SNAPSHOTDynamicData";
 import { EigenLayerDynamicData } from "./campaignTypes/EigenLayerDynamicData";
 import { EncompassingDynamicData } from "./campaignTypes/EncompassingDynamicData";
+import { EventBasedDynamicData } from "./campaignTypes/EventBasedDynamicData";
 import { HyperdriveDynamicData } from "./campaignTypes/HyperdriveDynamicData";
 import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData";
 import { MORPHODynamicData } from "./campaignTypes/MORPHODynamicData";
@@ -112,6 +113,10 @@ export async function campaignsDynamicData(chainId, campaigns, type) {
         case Campaign.ENCOMPASSING: {
             return EncompassingDynamicData(chainId, campaigns);
         }
+        case "EVENT_BASED":
+        case Campaign.EVENT_BASED: {
+            return EventBasedDynamicData(chainId, campaigns);
+        }
     }
     return {
         cached: false,

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

@@ -22,6 +22,7 @@ import { getEncompassingMetadata } from "./subservices/getEncompassingMetadata.s
 import { getErc20Metadata } from "./subservices/getErc20Metadata.service";
 import { getErc20SnapshotMetadata } from "./subservices/getErc20SnapshotMetadata.service";
 import { getEulerMetadata } from "./subservices/getEulerMetadata.service";
+import { getEventBasedMetadata } from "./subservices/getEventBasedMetadata.service.ts";
 import { getHyperdriveMetadata } from "./subservices/getHyperdriveMetadata.service";
 import { getJsonAirdropMetadata } from "./subservices/getJsonAirDropMetadata.service";
 import { getMorphoMetadata } from "./subservices/getMorphoMetadata.service";
@@ -99,6 +100,8 @@ export class OpportunityService {
                 return getUniswapV4Metadata(chainId, campaignParams);
             case "ENCOMPASSING":
                 return getEncompassingMetadata(chainId, campaign.rewardTokenAddress, campaignParams);
+            case "EVENT_BASED":
+                return getEventBasedMetadata(chainId, campaign.computeChainId, campaign.campaignId, campaign.rewardTokenAddress, campaign.amount, campaignParams);
             case "INVALID":
                 return {
                     name: "Invalid Campaigns",

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

@@ -0,0 +1,3 @@
+import type { OpportunityMetadata } from "..";
+import type { ChainId, EventBasedCampaign } from "@sdk";
+export declare const getEventBasedMetadata: (computeChainId: ChainId, _distributionChainId: ChainId, _campaignId: string, _rewardToken: string, _amount: string, params: EventBasedCampaign["campaignParameters"]) => Promise<OpportunityMetadata>;

package/dist/src/modules/v4/opportunity/subservices/getEventBasedMetadata.service.ts.js

@@ -0,0 +1,43 @@
+export const getEventBasedMetadata = async (computeChainId, _distributionChainId, _campaignId, _rewardToken, _amount, params) => {
+    try {
+        const action = "INVALID";
+        const mainProtocolId = "Hanji";
+        let name = `${params.eventID.split("(")[0]} on ${mainProtocolId}`;
+        let tokens = [{ chainId: computeChainId, address: params.contract }];
+        if (params.contract === "0xd0bc067cf877f7b76ceb331891331d9e6acda1a7") {
+            name = `Trade USDC/XTZ on ${mainProtocolId}`;
+            tokens = [
+                { chainId: computeChainId, address: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9" },
+                { chainId: computeChainId, address: "0xc9B53AB2679f573e480d01e0f49e2B5CFB7a3EAb" },
+            ];
+        }
+        if (params.contract === "0x65ea4dd7f789c71c0f57ed84b3bdc3062898d3cb") {
+            name = `Trade USDC/ETH on ${mainProtocolId}`;
+            tokens = [
+                { chainId: computeChainId, address: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9" },
+                { chainId: computeChainId, address: "0xfc24f770F94edBca6D6f885E12d4317320BcB401" },
+            ];
+        }
+        if (params.contract === "0xbb6b01d94e3f6ebae8647cb56d544f57928ab758") {
+            name = `Trade USDC/BTC on ${mainProtocolId}`;
+            tokens = [
+                { chainId: computeChainId, address: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9" },
+                { chainId: computeChainId, address: "0xbFc94CD2B1E55999Cfc7347a9313e88702B83d0F" },
+            ];
+        }
+        return {
+            action,
+            name,
+            tokens,
+            mainProtocol: mainProtocolId,
+        };
+    }
+    catch (error) {
+        return {
+            action: "INVALID",
+            name: "Event Based Campaign",
+            tokens: [],
+            mainProtocol: undefined,
+        };
+    }
+};