@merkl/api 0.10.152 → 0.10.154

package/package.json

@@ -90,5 +90,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "v0.10.152"
+  "version": "v0.10.154"
 }

package/dist/src/libs/rewards/userRewards.d.ts

@@ -1,2 +0,0 @@
-import { type ChainId } from "@sdk";
-export declare function getUserRewards(merklChainId: ChainId, merklRoot: string, user: string, mainParameter: string | undefined, rewardToken: string | undefined, proof: boolean): Promise<any>;

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

@@ -1,154 +0,0 @@
-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;
-}