@merkl/api 0.10.129 → 0.10.131

package/dist/src/libs/positions/prepareFetch.js

@@ -0,0 +1,339 @@
+import { Campaign, Forwarder, MorphoSubCampaignType, } from "@sdk";
+import { utils } from "ethers";
+function prepareClammFetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.CLAMM) {
+        return previous;
+    }
+    const amm = campaign.campaignParameters.amm;
+    // if (Object.values(PriorityAMM?.[campaign.chainId as any] ?? {}).includes(amm)) amm = AMM.UniswapV3;
+    if (!previous[amm]) {
+        previous[amm] = {};
+    }
+    if (!previous[amm][campaign.campaignParameters.poolAddress]) {
+        const forwarders = {};
+        if (campaign.forwarders && campaign.forwarders.length > 0) {
+            for (const forwarder of campaign.forwarders) {
+                forwarders[utils.getAddress(forwarder.almAddress)] = forwarder;
+            }
+        }
+        previous[amm][campaign.campaignParameters.poolAddress] = {
+            token0: campaign.campaignParameters.token0,
+            token1: campaign.campaignParameters.token1,
+            symbolToken0: campaign.campaignParameters.symbolToken0,
+            symbolToken1: campaign.campaignParameters.symbolToken1,
+            decimalsToken0: campaign.campaignParameters.decimalsToken0,
+            decimalsToken1: campaign.campaignParameters.decimalsToken1,
+            forwarders: forwarders,
+            poolBalanceToken0: campaign.poolBalanceToken0,
+            poolBalanceToken1: campaign.poolBalanceToken1,
+            poolTotalLiquidity: campaign.poolTotalLiquidity,
+            campaigns: {},
+        };
+    }
+    else {
+        const forwarders = previous[amm][campaign.campaignParameters.poolAddress].forwarders;
+        if (campaign.forwarders && campaign.forwarders.length > 0) {
+            for (const forwarder of campaign.forwarders) {
+                if (!forwarders[utils.getAddress(forwarder.almAddress)]) {
+                    forwarders[utils.getAddress(forwarder.almAddress)] = forwarder;
+                }
+            }
+        }
+        previous[amm][campaign.campaignParameters.poolAddress].forwarders = forwarders;
+    }
+    previous[amm][campaign.campaignParameters.poolAddress].campaigns[campaign.campaignId] = {
+        whitelist: campaign.campaignParameters.whitelist,
+        blacklist: campaign.campaignParameters.blacklist,
+        rewardToken: campaign.rewardToken,
+        decimalsRewardToken: campaign.campaignParameters.decimalsRewardToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        startTimestamp: campaign.startTimestamp,
+        endTimestamp: campaign.endTimestamp,
+        isOutOfRangeIncentivized: campaign.campaignParameters.isOutOfRangeIncentivized,
+        blacklistedLiquidity: campaign.blacklistedLiquidity,
+        blacklistedBalance0: campaign.blacklistedBalance0,
+        blacklistedBalance1: campaign.blacklistedBalance1,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+        propToken0: campaign.campaignParameters.weightToken0 / 1e5,
+        propToken1: campaign.campaignParameters.weightToken1 / 1e5,
+        propFees: campaign.campaignParameters.weightFees / 1e5,
+        mainParameter: campaign.mainParameter,
+    };
+    return previous;
+}
+function prepareERC20Fetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.ERC20) {
+        return previous;
+    }
+    if (!previous[campaign.campaignParameters.targetToken]) {
+        previous[campaign.campaignParameters.targetToken] = {
+            decimals: campaign.campaignParameters.decimalsTargetToken,
+            totalSupplyTargetToken: campaign.totalSupplyTargetToken,
+            priceTargetToken: !!campaign.typeInfo?.priceTargetToken ? campaign.typeInfo.priceTargetToken : 0,
+            campaigns: {},
+        };
+    }
+    previous[campaign.campaignParameters.targetToken].campaigns[campaign.campaignId] = {
+        rewardToken: campaign.rewardToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+    };
+    return previous;
+}
+function prepareDolomiteFetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.DOLOMITE) {
+        return previous;
+    }
+    if (!previous[campaign.mainParameter]) {
+        previous[campaign.mainParameter] = {
+            symbol: campaign.campaignParameters.symbolTargetToken,
+            decimals: campaign.campaignParameters.decimalsTargetToken,
+            targetToken: campaign.campaignParameters.targetToken,
+            totalSupplyTargetToken: campaign.totalSupplyTargetToken,
+            subCampaignType: campaign.campaignParameters.subCampaignType,
+            marketIndex: campaign.campaignParameters.marketIndex,
+            campaigns: {},
+        };
+    }
+    previous[campaign.mainParameter].campaigns[campaign.campaignId] = {
+        rewardToken: campaign.rewardToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+    };
+    return previous;
+}
+/**
+ * Silo
+ */
+function addForwarderToSiloCampaign(previousForwarder, // TODO @BaptistG typings
+newForward) {
+    if (!previousForwarder[newForward.sender]) {
+        previousForwarder[newForward.sender] = [];
+    }
+    if (newForward.forwarderType === Forwarder.ERC20) {
+        if (!previousForwarder[newForward.sender].includes(newForward.token)) {
+            previousForwarder[newForward.sender].push(newForward.token);
+        }
+    }
+    return previousForwarder;
+}
+function prepareSiloFetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.SILO) {
+        return previous;
+    }
+    if (!previous["allForwarders"]) {
+        previous["allForwarders"] = {};
+        previous["mainParameters"] = {};
+    }
+    if (!previous["mainParameters"][campaign.mainParameter]) {
+        previous["mainParameters"][campaign.mainParameter] = {
+            token: campaign.campaignParameters.targetToken,
+            decimals: campaign.campaignParameters.decimalsTargetToken,
+            symbol: campaign.campaignParameters.symbolTargetToken,
+            priceTargetToken: !!campaign.totalSupplyTargetToken && !!campaign.tvl ? campaign.tvl / campaign.totalSupplyTargetToken : 0,
+            campaigns: {},
+            allForwarders: {},
+        };
+    }
+    const forwarders = {};
+    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
+        for (const forwarder of campaign.campaignParameters.forwarders) {
+            if (campaign.campaignParameters.whitelist.length === 0 && campaign.campaignParameters.blacklist.length === 0) {
+                forwarders[utils.getAddress(forwarder.sender)] = forwarder;
+                previous["allForwarders"] = addForwarderToSiloCampaign(previous["allForwarders"], forwarder);
+                previous["mainParameters"][campaign.mainParameter].allForwarders = addForwarderToSiloCampaign(previous["mainParameters"][campaign.mainParameter].allForwarders, forwarder);
+            }
+            else if (campaign.campaignParameters.whitelist.length > 0) {
+                if (campaign.campaignParameters.whitelist.includes(utils.getAddress(forwarder.sender))) {
+                    forwarders[utils.getAddress(forwarder.sender)] = forwarder;
+                    previous["allForwarders"] = addForwarderToSiloCampaign(previous["allForwarders"], forwarder);
+                    previous["mainParameters"][campaign.mainParameter].allForwarders = addForwarderToSiloCampaign(previous["mainParameters"][campaign.mainParameter].allForwarders, forwarder);
+                }
+            }
+            else if (campaign.campaignParameters.blacklist.length > 0) {
+                if (!campaign.campaignParameters.blacklist.includes(utils.getAddress(forwarder.sender))) {
+                    forwarders[utils.getAddress(forwarder.sender)] = forwarder;
+                    previous["allForwarders"] = addForwarderToSiloCampaign(previous["allForwarders"], forwarder);
+                    previous["mainParameters"][campaign.mainParameter].allForwarders = addForwarderToSiloCampaign(previous["mainParameters"][campaign.mainParameter].allForwarders, forwarder);
+                }
+            }
+        }
+    }
+    previous["mainParameters"][campaign.mainParameter].campaigns[campaign.campaignId] = {
+        rewardToken: campaign.rewardToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+        forwarders: forwarders,
+    };
+    return previous;
+}
+/**
+ * Morpho
+ */
+function prepareMorphoFetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.MORPHO) {
+        return previous;
+    }
+    if (campaign.campaignSubType === MorphoSubCampaignType.META) {
+        previous[campaign.mainParameter] = {
+            rewardToken: campaign.rewardToken,
+            targetToken: campaign.campaignParameters.targetToken,
+            symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+            subtype: campaign.campaignSubType,
+            tvl: campaign.tvl,
+            marketId: campaign.campaignParameters.marketId,
+            decimals: campaign.campaignParameters.decimalsTargetToken,
+            totalSupplyTargetToken: campaign.totalSupplyTargetToken,
+            amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+            forwarders: {},
+        };
+    }
+    const forwarders = {};
+    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
+        for (const forwarder of campaign.campaignParameters.forwarders) {
+            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
+        }
+    }
+    previous[campaign.mainParameter] = {
+        rewardToken: campaign.rewardToken,
+        targetToken: campaign.campaignParameters.targetToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        subtype: campaign.campaignSubType,
+        tvl: campaign.tvl,
+        marketId: campaign.campaignParameters.marketId,
+        forwarders: forwarders,
+        decimals: campaign.campaignParameters.decimalsTargetToken,
+        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+    };
+    return previous;
+}
+/**
+ * Badger
+ */
+function prepareBadgerFetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.BADGER) {
+        return previous;
+    }
+    const forwarders = {};
+    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
+        for (const forwarder of campaign.campaignParameters.forwarders) {
+            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
+        }
+    }
+    previous[campaign.mainParameter] = {
+        rewardToken: campaign.rewardToken,
+        targetToken: campaign.campaignParameters.targetToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        subtype: campaign.campaignSubType,
+        tvl: campaign.tvl,
+        forwarders: forwarders,
+        decimals: campaign.campaignParameters.decimalsTargetToken,
+        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+    };
+    return previous;
+}
+/**
+ * Ajna
+ */
+function prepareAjnaFetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.AJNA) {
+        return previous;
+    }
+    const forwarders = {};
+    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
+        for (const forwarder of campaign.campaignParameters.forwarders) {
+            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
+        }
+    }
+    previous[campaign.mainParameter] = {
+        rewardToken: campaign.rewardToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        subtype: campaign.campaignSubType,
+        tvl: campaign.tvl,
+        forwarders: forwarders,
+        quoteToken: campaign.campaignParameters.quoteToken,
+        poolId: campaign.campaignParameters.poolId,
+        decimalsQuoteToken: campaign.campaignParameters.decimalsQuoteToken,
+        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
+        computedtotalSupply: campaign.computedtotalSupply,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+    };
+    return previous;
+}
+/**
+ * Euler
+ */
+function prepareEulerFetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.EULER) {
+        return previous;
+    }
+    if (!previous[campaign.campaignParameters.targetToken]) {
+        previous[campaign.campaignParameters.targetToken] = {
+            decimals: campaign.campaignParameters.decimalsTargetToken,
+            totalSupplyTargetToken: campaign.totalSupplyTargetToken,
+            priceTargetToken: !!campaign.typeInfo?.priceTargetToken ? campaign.typeInfo.priceTargetToken : 0,
+            campaigns: {},
+        };
+    }
+    previous[campaign.campaignParameters.targetToken].campaigns[campaign.campaignId] = {
+        rewardToken: campaign.rewardToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+    };
+    return previous;
+}
+function prepareCompoundFetch(previous, campaign) {
+    if (campaign.campaignType !== Campaign.COMPOUND) {
+        return previous;
+    }
+    const forwarders = {};
+    if (campaign.campaignParameters.forwarders && campaign.campaignParameters.forwarders.length > 0) {
+        for (const forwarder of campaign.campaignParameters.forwarders) {
+            forwarders[utils.getAddress(forwarder.sender)] = forwarder;
+        }
+    }
+    previous[campaign.mainParameter] = {
+        rewardToken: campaign.rewardToken,
+        symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+        subtype: campaign.campaignSubType,
+        compFork: campaign.campaignParameters.compFork,
+        tvl: campaign.tvl,
+        forwarders: forwarders,
+        targetToken: campaign.campaignParameters.targetToken,
+        decimalsTargetToken: campaign.campaignParameters.decimalsTargetToken,
+        totalSupplyTargetToken: campaign.totalSupplyTargetToken,
+        underlyingToken: campaign.campaignParameters.underlyingToken,
+        symbolUnderlyingToken: campaign.campaignParameters.symbolUnderlyingToken,
+        decimalsUnderlyingToken: campaign.campaignParameters.decimalsUnderlyingToken,
+        symbolTargetToken: campaign.campaignParameters.symbolTargetToken,
+        amount: Number.parseFloat((BigInt(campaign.amount) / BigInt(10 ** campaign.campaignParameters.decimalsRewardToken)).toString()),
+    };
+    return previous;
+}
+export function prepareFetch(type, previous, // FIXME
+campaign) {
+    switch (type) {
+        case Campaign.CLAMM:
+            return prepareClammFetch(previous, campaign);
+        case Campaign.ERC20:
+            return prepareERC20Fetch(previous, campaign);
+        case Campaign.SILO:
+            return prepareSiloFetch(previous, campaign);
+        case Campaign.DOLOMITE:
+            return prepareDolomiteFetch(previous, campaign);
+        case Campaign.MORPHO:
+            return prepareMorphoFetch(previous, campaign);
+        case Campaign.BADGER:
+            return prepareBadgerFetch(previous, campaign);
+        case Campaign.EULER:
+            return prepareEulerFetch(previous, campaign);
+        case Campaign.AJNA:
+            return prepareAjnaFetch(previous, campaign);
+        case Campaign.COMPOUND:
+            return prepareCompoundFetch(previous, campaign);
+        default:
+            return previous;
+    }
+}

package/dist/src/libs/positions/silo/index.js

@@ -0,0 +1,67 @@
+import { BN2Number, ERC20Interface } from "@sdk";
+import { getAddress } from "ethers/lib/utils";
+export async function getSiloUserPositions(user, _chainId, mainParameters) {
+    /**
+     * Fetch user positions
+     */
+    const sendTokenMapping = {};
+    const calls = [];
+    let i = 0;
+    for (const [sender, tokens] of Object.entries(mainParameters.allForwarders)) {
+        for (const token of tokens) {
+            if (!sendTokenMapping[`${sender}_${token}`] && !(sendTokenMapping[`${sender}_${token}`] === 0)) {
+                calls.push({
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
+                    target: token,
+                });
+                calls.push({
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: token,
+                });
+                sendTokenMapping[`${sender}_${token}`] = i;
+                i++;
+            }
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const finalRes = {};
+                for (const mainParameter of Object.keys(mainParameters.mainParameters)) {
+                    const res = {
+                        userPositions: [],
+                        symbol: mainParameters.mainParameters[mainParameter].symbol,
+                        decimals: mainParameters.mainParameters[mainParameter].decimals,
+                        token: mainParameters.mainParameters[mainParameter].token,
+                        userTVL: 0,
+                    };
+                    for (const [sender, tokens] of Object.entries(mainParameters.mainParameters[mainParameter].allForwarders)) {
+                        for (const token of tokens) {
+                            // Direct Positions
+                            const balance = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[2 * sendTokenMapping[`${sender}_${token}`]])[0]);
+                            if (balance > 0) {
+                                res.userPositions.push({
+                                    balance: balance,
+                                    token: getAddress(token),
+                                    origin: "Direct",
+                                    totalSupply: BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[1 + 2 * sendTokenMapping[`${sender}_${token}`]])[0], res.decimals),
+                                    tvl: mainParameters.mainParameters[mainParameter].priceTargetToken * balance,
+                                });
+                                res.userTVL += mainParameters.mainParameters[mainParameter].priceTargetToken * balance;
+                            }
+                        }
+                    }
+                    if (res.userPositions.length > 0) {
+                        finalRes[`5_${mainParameter}`] = { ...res };
+                    }
+                }
+                return finalRes;
+            },
+        },
+    };
+}

package/dist/src/libs/positions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/libs/reports/campaignReport.js

@@ -0,0 +1,37 @@
+import { Redis } from "../../cache";
+import { MerklRootService } from "../../modules/v4/merklRoot";
+import { hashArray } from "../../utils/hashArray";
+import { engineDbClient } from "../../utils/prisma";
+import { CAMPAIGN_REWARDS_DELTA, LATEST_CAMPAIGNS_REWARDS, } from "../../utils/queries/rewardsAmount";
+async function getCampaignRewards(chainId, root, campaignId) {
+    return await engineDbClient.$queryRaw(LATEST_CAMPAIGNS_REWARDS(chainId, root, [campaignId]));
+}
+export const getCampaignRewardsWithCache = async (chainId, root, campaignId) => {
+    return await Redis.getOrSet(`CampaignRewards_${hashArray([chainId, root, campaignId])}`, getCampaignRewards, chainId, root, campaignId);
+};
+async function getCampaignRewardsDelta(chainId, from, to, campaignId) {
+    const roots = await MerklRootService.rootForTimestamp({
+        chainId,
+        fromTimestamp: from.toString(),
+        toTimestamp: to.toString(),
+    });
+    let toRoot;
+    let fromRoot;
+    if (roots.length === 2) {
+        toRoot = roots[0].root;
+        fromRoot = roots[1].root;
+    }
+    else if (roots.length === 1) {
+        // This means that the from timestamp is before the first root so we can simply return the state at the toRoot
+        toRoot = roots[0].root;
+        const rewardsData = await engineDbClient.$queryRaw(LATEST_CAMPAIGNS_REWARDS(chainId, toRoot, [campaignId]));
+        return rewardsData;
+    }
+    else {
+        return [];
+    }
+    return (await engineDbClient.$queryRaw(CAMPAIGN_REWARDS_DELTA(chainId, campaignId, fromRoot, toRoot)));
+}
+export const getCampaignRewardsDeltaWithCache = async (chainId, from, to, campaignId) => {
+    return await Redis.getOrSet(`CampaignRewardsDelta_${hashArray([chainId, from, to, campaignId])}`, getCampaignRewardsDelta, chainId, from, to, campaignId);
+};

package/dist/src/libs/reports/mainParameterRewards.js

@@ -0,0 +1,48 @@
+import { Redis } from "../../cache";
+import { MerklRootService } from "../../modules/v4/merklRoot";
+import { hashArray } from "../../utils/hashArray";
+import { engineDbClient } from "../../utils/prisma";
+import { CAMPAIGNS_FOR_MAIN_PARAMETER, } from "../../utils/queries/mainParameterCampaigns";
+import { LATEST_CAMPAIGNS_REWARDS, REWARDS_DELTA, } from "../../utils/queries/rewardsAmount";
+async function getRewardsMainParameter(chainId, root, mainParameter) {
+    const rawCampaigns = await engineDbClient.$queryRaw(CAMPAIGNS_FOR_MAIN_PARAMETER(chainId, mainParameter));
+    const campaignIds = rawCampaigns.map(campaign => campaign.campaignId);
+    if (campaignIds.length === 0) {
+        return [];
+    }
+    return await engineDbClient.$queryRaw(LATEST_CAMPAIGNS_REWARDS(chainId, root, campaignIds));
+}
+export const getRewardsMainParameterWithCache = async (chainId, root, mainParameter) => {
+    return await Redis.getOrSet(`RewardsMainParameter_${hashArray([chainId, root, mainParameter])}`, getRewardsMainParameter, chainId, root, mainParameter);
+};
+async function getRewardsMainParameterDelta(chainId, from, to, mainParameter) {
+    const roots = await MerklRootService.rootForTimestamp({
+        chainId,
+        fromTimestamp: from.toString(),
+        toTimestamp: to.toString(),
+    });
+    const rawCampaigns = await engineDbClient.$queryRaw(CAMPAIGNS_FOR_MAIN_PARAMETER(chainId, mainParameter));
+    const campaignIds = rawCampaigns.map(campaign => campaign.campaignId);
+    if (campaignIds.length === 0) {
+        return [];
+    }
+    let toRoot;
+    let fromRoot;
+    if (roots.length === 2) {
+        toRoot = roots[0].root;
+        fromRoot = roots[1].root;
+    }
+    else if (roots.length === 1) {
+        // This means that the from timestamp is before the first root so we can simply return the state at the toRoot
+        toRoot = roots[0].root;
+        const rewardsData = await engineDbClient.$queryRaw(LATEST_CAMPAIGNS_REWARDS(chainId, toRoot, campaignIds));
+        return rewardsData;
+    }
+    else {
+        return [];
+    }
+    return (await engineDbClient.$queryRaw(REWARDS_DELTA(chainId, campaignIds, fromRoot, toRoot)));
+}
+export const getRewardsMainParameterDeltaWithCache = async (chainId, from, to, mainParameter) => {
+    return await Redis.getOrSet(`RewardsMainParameterDelta_${hashArray([chainId, from, to, mainParameter])}`, getRewardsMainParameterDelta, chainId, from, to, mainParameter);
+};

package/dist/src/libs/rewards/userRewards.js

@@ -0,0 +1,154 @@
+import { engineDbClient } from "../../utils/prisma";
+import { DistributorInterface, NETWORK_LABELS, registry } from "@sdk";
+import Big from "big.js";
+import { BigNumber } from "ethers";
+import { batchMulticallCallWithRetry } from "../../utils/generic";
+export async function getUserRewards(merklChainId, merklRoot, user, mainParameter, rewardToken, proof) {
+    if (!merklRoot)
+        throw new Error(`No merklRoot when calling getUserRewards on ${NETWORK_LABELS[merklChainId]} for ${user}`);
+    const res = {};
+    let filters = {
+        chainId: merklChainId,
+        recipient: user,
+    };
+    if (rewardToken) {
+        filters = {
+            ...filters,
+            rewardToken: rewardToken,
+        };
+    }
+    const [leaves, claims] = await engineDbClient.$transaction([
+        engineDbClient.leaves.findMany({ where: { ...filters, root: merklRoot } }),
+        engineDbClient.claims.findMany({ where: { ...filters } }),
+    ]);
+    const calls = [];
+    const earnedTokens = [];
+    const claimedTokenAmounts = {};
+    for (const leaf of leaves) {
+        if (!earnedTokens.includes(leaf.rewardToken)) {
+            earnedTokens.push(leaf.rewardToken);
+        }
+    }
+    for (const token of earnedTokens) {
+        calls.push({
+            target: registry(merklChainId)?.Merkl?.Distributor,
+            callData: DistributorInterface.encodeFunctionData("claimed", [user, token]),
+            allowFailure: true,
+        });
+    }
+    const claimedCallResult = await batchMulticallCallWithRetry(merklChainId, { calls });
+    const fullyClaimedTokens = [];
+    for (const [index, token] of earnedTokens.entries()) {
+        const amount = DistributorInterface.decodeFunctionResult("claimed", claimedCallResult[index].returnData)[0];
+        const root = DistributorInterface.decodeFunctionResult("claimed", claimedCallResult[index].returnData)[2];
+        claimedTokenAmounts[token] = amount;
+        if (root === merklRoot) {
+            fullyClaimedTokens.push(token);
+        }
+    }
+    let campaignFilters = {
+        campaignId: { in: leaves.map(leaf => leaf.campaignId) },
+        chainId: merklChainId,
+    };
+    if (mainParameter) {
+        campaignFilters = {
+            ...campaignFilters,
+            mainParameter: mainParameter,
+        };
+    }
+    if (rewardToken) {
+        campaignFilters = {
+            ...campaignFilters,
+            rewardToken: rewardToken,
+        };
+    }
+    const campaigns = await engineDbClient.campaigns.findMany({ where: campaignFilters });
+    const campaignMapping = campaigns.reduce((prev, campaign) => {
+        prev[`${campaign.chainId}_${campaign.campaignId}`] = campaign;
+        return prev;
+    }, {});
+    if (leaves.length === 0) {
+        return {};
+    }
+    const proofMapping = {};
+    if (proof) {
+        const proofs = await engineDbClient.proofs.findMany({
+            select: {
+                chainId: true,
+                proof: true,
+                rewardToken: true,
+            },
+            where: {
+                chainId: merklChainId,
+                recipient: user,
+                root: merklRoot,
+            },
+        });
+        // Create a map of proofs for each token
+        for (const proof of proofs) {
+            if (!Object.hasOwn(proofMapping, proof.chainId)) {
+                proofMapping[proof.chainId] = {};
+            }
+            proofMapping[proof.chainId][proof.rewardToken] = proof.proof;
+        }
+    }
+    for (const leaf of leaves) {
+        if (mainParameter && campaignMapping[`${leaf.chainId}_${leaf.campaignId}`]?.mainParameter !== mainParameter) {
+            continue;
+        }
+        if (!Object.hasOwn(res, leaf.rewardToken)) {
+            res[leaf.rewardToken] = {
+                accumulated: leaf.amount,
+                decimals: campaignMapping?.[`${leaf.chainId}_${leaf.campaignId}`]?.campaignParameters
+                    ?.decimalsRewardToken,
+                reasons: {},
+                symbol: campaignMapping?.[`${leaf.chainId}_${leaf.campaignId}`]?.campaignParameters?.symbolRewardToken,
+                unclaimed: fullyClaimedTokens.includes(leaf.rewardToken) ? "0" : leaf.amount,
+            };
+            if (proof) {
+                res[leaf.rewardToken].proof = proofMapping?.[leaf.chainId]?.[leaf.rewardToken] ?? [];
+            }
+        }
+        else {
+            res[leaf.rewardToken].accumulated = new Big(leaf.amount)
+                .add(new Big(res[leaf.rewardToken].accumulated))
+                .toFixed(0);
+            res[leaf.rewardToken].unclaimed = fullyClaimedTokens.includes(leaf.rewardToken)
+                ? "0"
+                : new Big(leaf.amount).add(new Big(res[leaf.rewardToken].unclaimed)).toFixed(0);
+        }
+        if (!Object.hasOwn(res[leaf.rewardToken].reasons, leaf.reason)) {
+            res[leaf.rewardToken].reasons[leaf.reason] = {
+                accumulated: leaf.amount,
+                unclaimed: fullyClaimedTokens.includes(leaf.rewardToken) ? "0" : leaf.amount,
+            };
+        }
+        else {
+            res[leaf.rewardToken].reasons[leaf.reason].accumulated = new Big(leaf.amount)
+                .add(new Big(res[leaf.rewardToken].reasons[leaf.reason].accumulated))
+                .toFixed(0);
+            res[leaf.rewardToken].reasons[leaf.reason].unclaimed = fullyClaimedTokens.includes(leaf.rewardToken)
+                ? "0"
+                : new Big(leaf.amount).add(new Big(res[leaf.rewardToken].reasons[leaf.reason].unclaimed)).toFixed(0);
+        }
+    }
+    for (const claim of claims) {
+        if (mainParameter && campaignMapping[`${claim.chainId}_${claim.campaignId}`]?.mainParameter !== mainParameter) {
+            continue;
+        }
+        if (!!res?.[claim.rewardToken] && !fullyClaimedTokens.includes(claim.rewardToken)) {
+            res[claim.rewardToken].unclaimed = new Big(res[claim.rewardToken].unclaimed).sub(claim.claimed).toFixed(0);
+            if (!!res[claim.rewardToken].reasons?.[claim.reason]) {
+                res[claim.rewardToken].reasons[claim.reason].unclaimed = new Big(res[claim.rewardToken].reasons[claim.reason].unclaimed)
+                    .sub(claim.claimed)
+                    .toFixed(0);
+            }
+        }
+    }
+    for (const token of Object.keys(res)) {
+        if (BigNumber.from(res[token].accumulated).lte(claimedTokenAmounts?.[token] ?? "0") && !mainParameter) {
+            res[token].unclaimed = "0";
+        }
+    }
+    return res;
+}

package/dist/src/libs/staticCampaigns.js

@@ -0,0 +1,10 @@
+import { Redis } from "../cache";
+import { engineDbClient } from "../utils/prisma";
+async function staticCampaigns(chainId) {
+    return await engineDbClient.campaigns.findMany({
+        where: {
+            chainId: chainId,
+        },
+    });
+}
+export const staticCampaignWithCache = async (chainId) => await Redis.getOrSet(`StaticCampaigns_${chainId}`, staticCampaigns, chainId);