@merkl/api 0.10.361 → 0.10.362

package/package.json

@@ -93,5 +93,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "v0.10.361"
+  "version": "v0.10.362"
 }

package/dist/src/jobs/breakdowns.d.ts

@@ -1 +0,0 @@
-export declare const writeBreakdownsToAPI: (chainId: number, root: string) => Promise<void>;

package/dist/src/jobs/breakdowns.js

@@ -1,55 +0,0 @@
-import { CampaignService, TokenService } from "../modules/v4";
-import { BucketService } from "../modules/v4/bucket/bucket.service";
-import { RewardService } from "../modules/v4/reward";
-import { log } from "../utils/logger";
-import { apiDbClient } from "../utils/prisma";
-import moment from "moment";
-// @dev Trigger at the end of the rewards job
-export const writeBreakdownsToAPI = async (chainId, root) => {
-    const start = moment().unix();
-    const environmentName = process.env.ENV === "staging" ? "staging" : "production";
-    const breakdownBatches = [[]];
-    const breakdownBatchPromises = [];
-    let currentBreakdownBatchIndex = 0;
-    const pushBreakdowns = async (index) => {
-        log.local(`pushing breakdown batch ${index} (${breakdownBatches[index].length} points) to API DB`);
-        // Upsert users in case they don't exist yet
-        const breakdownsToCreate = [];
-        for (const b of breakdownBatches[index]) {
-            const campaignId = CampaignService.hashId({ distributionChain: chainId, campaignId: b.campaignId });
-            const rewardTokenId = TokenService.hashId({ chainId, address: b.token });
-            const rewardId = RewardService.hashId(root, b.recipient, rewardTokenId);
-            breakdownsToCreate.push({
-                rewardId,
-                protocolId: b.protocolId ? b.protocolId : undefined,
-                campaignId,
-                reason: b.reason ? b.reason : "",
-                amount: b.amount,
-                claimed: b.claimed,
-                pending: b.pending,
-                auxiliaryData1: b.auxiliaryData1 ?? "",
-                auxiliaryData2: b.auxiliaryData2 ?? "",
-            });
-        }
-        return (await apiDbClient.rewardBreakdown.createMany({
-            data: breakdownsToCreate,
-            skipDuplicates: true, // To avoid revert if data already exists
-        })).count;
-    };
-    await BucketService.readStreamFromBucket(`breakdowns/${chainId}-${root}.gz`, `merkl-rewards-lake-${environmentName}`, `merkl-data-${environmentName}`, async (x) => {
-        const breakdowns = JSON.parse(x);
-        for (const b of breakdowns) {
-            breakdownBatches[currentBreakdownBatchIndex].push(b);
-            if (breakdownBatches[currentBreakdownBatchIndex].length >= 30_000) {
-                breakdownBatchPromises.push(pushBreakdowns(currentBreakdownBatchIndex));
-                breakdownBatches.push([]);
-                currentBreakdownBatchIndex++;
-            }
-        }
-        return;
-    });
-    // Final batch
-    breakdownBatchPromises.push(pushBreakdowns(currentBreakdownBatchIndex));
-    const breakdownsCreated = (await Promise.all(breakdownBatchPromises)).reduce((acc, x) => acc + x, 0);
-    log.info(`✅ Successfully created ${breakdownsCreated} breakdowns in ${moment().unix() - start}sec`);
-};

package/dist/src/jobs/rewards.d.ts

@@ -1 +0,0 @@
-export declare const writeRewardsToAPI: (chainId: number, root: string) => Promise<void>;

package/dist/src/jobs/rewards.js

@@ -1,74 +0,0 @@
-import { TokenService } from "../modules/v4";
-import { BucketService } from "../modules/v4/bucket/bucket.service";
-import { RewardService } from "../modules/v4/reward";
-import { log } from "../utils/logger";
-import { apiDbClient } from "../utils/prisma";
-import { HOUR } from "@sdk";
-import moment from "moment";
-import { writeBreakdownsToAPI } from "./breakdowns";
-export const writeRewardsToAPI = async (chainId, root) => {
-    const start = moment().unix();
-    const environmentName = process.env.ENV === "staging" ? "staging" : "production";
-    const now = moment().unix();
-    // Upsert root
-    await apiDbClient.merklRoot.upsert({
-        create: {
-            root,
-            chainId,
-            epoch: Math.floor(now / HOUR),
-            timestamp: now,
-        },
-        update: {},
-        where: {
-            root,
-        },
-    });
-    // Read reward stream and populate the table
-    const rewardBatches = [[]];
-    const rewardBatchPromises = [];
-    let currentRewardBatchIndex = 0;
-    const pushRewards = async (index) => {
-        log.local(`pushing rewards batch ${index} (${rewardBatches[index].length} points) to API DB`);
-        // Upsert users in case they don't exist yet
-        await apiDbClient.user.createMany({
-            data: rewardBatches[index].map(r => {
-                return {
-                    address: r.recipient,
-                };
-            }),
-            skipDuplicates: true,
-        });
-        const rewardsToCreate = rewardBatches[index].map(reward => {
-            const rewardTokenId = TokenService.hashId({ chainId, address: reward.rewardToken });
-            const id = RewardService.hashId(root, reward.recipient, rewardTokenId);
-            return {
-                id,
-                root: reward.root,
-                amount: reward.amount,
-                pending: reward.pending,
-                claimed: reward.claimed,
-                recipient: reward.recipient,
-                rewardTokenId,
-                proofs: reward.proofs,
-            };
-        });
-        return (await apiDbClient.reward.createMany({
-            data: rewardsToCreate,
-            skipDuplicates: true, // To avoid revert if data already exists
-        })).count;
-    };
-    await BucketService.readStreamFromBucket(`rewards/${chainId}-${root}.gz`, `merkl-rewards-lake-${environmentName}`, `merkl-data-${environmentName}`, async (x) => {
-        rewardBatches[currentRewardBatchIndex].push(JSON.parse(x));
-        if (rewardBatches[currentRewardBatchIndex].length >= 20_000) {
-            rewardBatchPromises.push(pushRewards(currentRewardBatchIndex));
-            currentRewardBatchIndex++;
-            rewardBatches.push([]);
-        }
-        return;
-    });
-    // Final batch
-    rewardBatchPromises.push(pushRewards(currentRewardBatchIndex));
-    const rewardsCreated = (await Promise.all(rewardBatchPromises)).reduce((acc, x) => acc + x, 0);
-    log.info(`✅ Successfully created ${rewardsCreated} rewards in ${moment().unix() - start}sec`);
-    await writeBreakdownsToAPI(chainId, root);
-};