@merkl/api 0.9.15

package/dist/src/index.js

@@ -0,0 +1,111 @@
+import { cors } from "@elysiajs/cors";
+import { swagger } from "@elysiajs/swagger";
+import axios from "axios";
+import { Elysia } from "elysia";
+import { apiDbClient, engineDbClient } from "../database";
+import { redisClient } from "./cache/redis";
+import { v4 } from "./modules/v4/router";
+import { v1 } from "./routes/v1/router";
+import { v2 } from "./routes/v2/router";
+import { v3 } from "./routes/v3/router";
+import { errorHandler } from "./utils/error";
+import { log } from "./utils/logger";
+// Axios with bun workaround
+axios.defaults.headers.common["Accept-Encoding"] = "gzip";
+const PORT = process.env.PORT || 3000;
+const app = new Elysia({
+    normalize: false,
+    serve: {
+        maxRequestBodySize: 1024 * 1024 * 1024, // 1GB
+        idleTimeout: 0,
+    },
+})
+    .use(swagger({
+    scalarConfig: {
+        theme: "kepler",
+        darkMode: true,
+        favicon: "https://app.merkl.xyz/images/merkl-favicon.ico",
+    },
+    documentation: {
+        info: {
+            contact: {
+                email: "contact@merkl.money",
+                name: "Angle Labs",
+            },
+            description: "The official API to access data related to Merkl campaigns, built and maintained by Angle Labs. This API is provided as is, without any warranty of any kind.",
+            license: {
+                name: "UNLICENSED",
+            },
+            title: "Merkl API",
+            version: "1.0.1",
+        },
+    },
+    exclude: [/v4\/.*/, "/"],
+}))
+    .use(swagger({
+    path: "/docs",
+    scalarConfig: {
+        theme: "kepler",
+        darkMode: true,
+        favicon: "https://app.merkl.xyz/images/merkl-favicon.ico",
+    },
+    documentation: {
+        tags: [
+            {
+                name: "Opportunities",
+                description: "An opportunity represents a collection of campaigns.",
+            },
+            {
+                name: "Campaigns",
+                description: "Campaigns are designed to incentivize participation in a protocol by offering rewards to users for specific behaviors or actions.",
+            },
+            {
+                name: "Protocols",
+                description: "Endpoints related to protocols integrated by Merkl.",
+            },
+            {
+                name: "Chains",
+                description: "Endpoints related to chains integrated by Merkl.",
+            },
+            {
+                name: "Users",
+                description: "Endpoints related to Merkl users.",
+            },
+        ],
+        info: {
+            contact: {
+                email: "contact@merkl.money",
+                name: "Angle Labs",
+            },
+            description: "The official API to access data related to Merkl campaigns, built and maintained by Angle Labs. This API is provided as is, without any warranty of any kind.",
+            license: {
+                name: "UNLICENSED",
+            },
+            title: "Merkl API",
+            version: "1.0.1",
+        },
+    },
+    exclude: [/engine\/*/, /v1\/.*/, /v2\/.*/, /v3\/.*/, /swagger\/*/],
+}))
+    .use(cors())
+    .get("/", () => "Merkl API: docs available at /docs", {
+    detail: {
+        hide: true,
+    },
+})
+    .use(v1)
+    .use(v2)
+    .use(v4)
+    .use(v3)
+    .use(errorHandler())
+    .listen({ port: PORT, idleTimeout: 40 }, ({ hostname, port }) => {
+    log.info(`🌐  Api started (${hostname}:${port})`);
+});
+// ─── Signal Handling ─────────────────────────────────────────────────────────
+process.on("SIGTERM", () => {
+    engineDbClient.$disconnect();
+    apiDbClient.$disconnect();
+    redisClient.disconnect();
+    process.exit();
+});
+export { app };

package/dist/src/jobs/dynamic-data.d.ts

@@ -0,0 +1,9 @@
+import { type Campaign, type CampaignDynamicData } from "@sdk";
+export type CampaignsCacheUpdaterReturnType = {
+    [type_mainParameter: string]: {
+        [campaignId: string]: CampaignDynamicData<Campaign>;
+    };
+};
+export declare const main: () => Promise<{
+    success: boolean;
+}>;

package/dist/src/jobs/dynamic-data.js

@@ -0,0 +1,24 @@
+import { campaignCacheUpdate } from "@/backgroundJobs/jobs/campaignsCacheUpdater";
+import { InvalidParameter, UnsupportedNetwork } from "@/utils/error";
+import { ChainId, isSupportedChain } from "@sdk";
+const campaignTypes = process.env.CAMPAIGN_TYPES ? JSON.parse(process.env.CAMPAIGN_TYPES) : [];
+const highCampaignsChains = [ChainId.ARBITRUM, ChainId.POLYGON, ChainId.BLAST, ChainId.BASE];
+export const main = async () => {
+    const rawChainId = process.env.CHAIN_ID;
+    let chainId;
+    if (typeof rawChainId === "string") {
+        chainId = Number.parseInt(rawChainId);
+        if (!isSupportedChain(chainId, "merkl"))
+            throw new UnsupportedNetwork(chainId);
+    }
+    else {
+        throw new InvalidParameter("Invalid chainId provided");
+    }
+    return campaignCacheUpdate(rawChainId, campaignTypes, highCampaignsChains);
+};
+main()
+    .then(success => (success ? process.exit(0) : process.exit(1)))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

@@ -0,0 +1 @@
+export declare const main: () => Promise<void>;

package/dist/src/jobs/pendings.js

@@ -0,0 +1,236 @@
+// ─── Pending Rewards Etl ─────────────────────────────────────────────────────
+if (!process.env.ENV || !process.env.FILENAME)
+    throw new Error("[ENV]: missing variable");
+import { log } from "@/utils/logger";
+import { apiDbClient } from "@db";
+import { NETWORK_LABELS, withRetry } from "@sdk";
+import { S3Client } from "bun";
+import moment from "moment";
+// ─── Constants ───────────────────────────────────────────────
+const MAX_BATCH_SIZE = 1_000;
+// ─── Global Variables ────────────────────────────────────────
+const [chainIdString, root, campaignId] = process.env.FILENAME.replace(".gz", "").split("_");
+const chainId = Number.parseInt(chainIdString);
+const gcsClient = new S3Client({
+    accessKeyId: process.env.GCS_ACCESS_ID,
+    secretAccessKey: process.env.GCS_SECRET,
+    endpoint: process.env.GCS_ENDPOINT,
+    bucket: `merkl-rewards-lake-${process.env.ENV}`,
+});
+const file = gcsClient.file(`pendings/${process.env.FILENAME}`);
+// ─── Extract ─────────────────────────────────────────────────────────────────
+const extract = async () => {
+    if (!file.exists())
+        throw new Error("File does not exist.");
+    const textDecoder = new TextDecoder();
+    let buffer = "";
+    const stream = file.stream();
+    let data = [];
+    const loadPromises = [];
+    for await (const chunk of stream) {
+        buffer += textDecoder.decode(chunk);
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            data.push(JSON.parse(line));
+        }
+        if (data.length < MAX_BATCH_SIZE)
+            continue;
+        // Retry up to 5 times with a 10s delay
+        const promise = withRetry(load, [data], 5, 10_000);
+        loadPromises.push(promise);
+        await promise;
+        data = [];
+    }
+    // Final batch
+    // Retry up to 5 times with a 10s delay
+    const promise = withRetry(load, [data], 5, 10_000);
+    loadPromises.push(promise);
+    await promise;
+    let created = 0;
+    let updated = 0;
+    let failed = 0;
+    const promiseResults = await Promise.allSettled(loadPromises);
+    for (const x of promiseResults) {
+        if (x.status === "rejected")
+            failed += 1;
+        else {
+            updated += x.value.updated;
+            created += x.value.created;
+        }
+    }
+    return { created, updated, failed, batch: promiseResults.length };
+};
+// ─── Transform & Load ────────────────────────────────────────────────────────
+const load = async (pendings) => {
+    if (pendings.length === 0)
+        return { updated: 0, created: 0 };
+    log.info(`pushing ${pendings.length} pendings for token ${pendings[0].rewardToken} on ${NETWORK_LABELS[chainId]}`);
+    const { updated, created } = await updatePendings({
+        distributionChainId: chainId,
+        rewardToken: pendings[0].rewardToken, // sometimes undefined
+        campaignId,
+        root,
+        data: pendings,
+    });
+    log.info(`✅ updated ${updated} and created ${created} pendings`);
+    return { updated, created };
+};
+const updatePendings = async (data) => {
+    const rewardTokenId = Bun.hash(`${data.distributionChainId}${data.rewardToken}`).toString();
+    const campaignId = Bun.hash(`${data.distributionChainId}${data.campaignId}`).toString();
+    // List of identifiers of breakdowns that will be touched by this jobd
+    const breakdownUniques = await data.data.map(({ recipient, reason }) => {
+        const rewardId = Bun.hash(`${data.root}${recipient}${rewardTokenId}`).toString();
+        return { rewardId, reason, campaignId };
+    });
+    // Check if these breakdowns already exist or not
+    const breakdownExists = await apiDbClient.$transaction(breakdownUniques.map(x => apiDbClient.rewardBreakdown.findUnique({
+        select: {
+            pending: true,
+        },
+        where: {
+            rewardId_campaignId_reason: {
+                rewardId: x.rewardId,
+                campaignId: x.campaignId,
+                reason: x.reason,
+            },
+        },
+    })));
+    // We want to get all current pendings for the rewardIds that will be modified
+    // Should contain rewardId => { pendingIncrease, recipient }
+    const rewardIdToPendingIncrease = {};
+    const breakdownToUpdate = [];
+    const breakdownToCreate = [];
+    let totalBreakdownIncrease = 0n;
+    // For all point to update
+    //  - compute the delta with what's in database, add it to rewardIdToPendingIncrease
+    //  - add the point to breakdownToUpdate or breakdownToCreate
+    for (const [pointIndex, point] of data.data.entries()) {
+        const rewardId = Bun.hash(`${data.root}${point.recipient}${rewardTokenId}`).toString();
+        if (!rewardIdToPendingIncrease[rewardId]) {
+            rewardIdToPendingIncrease[rewardId] = { pendingIncrease: 0n, recipient: point.recipient };
+        }
+        const delta = BigInt(point.pending) - BigInt(breakdownExists[pointIndex]?.pending ?? "0");
+        totalBreakdownIncrease += delta;
+        if (delta > 0n) {
+            rewardIdToPendingIncrease[rewardId].pendingIncrease += delta; // Store the delta
+            if (!!breakdownExists[pointIndex]) {
+                breakdownToUpdate.push(point);
+            }
+            else {
+                breakdownToCreate.push(point);
+            }
+        }
+    }
+    const rewardToUpdate = [];
+    const rewardToCreate = [];
+    const RewardExists = await apiDbClient.$transaction(Object.keys(rewardIdToPendingIncrease).map(x => apiDbClient.reward.findUnique({
+        select: {
+            pending: true,
+        },
+        where: {
+            id: x,
+        },
+    })));
+    for (const [pointIndex, point] of Object.values(rewardIdToPendingIncrease).entries()) {
+        if (BigInt(point.pendingIncrease) > 0n) {
+            const rewardExists = RewardExists[pointIndex];
+            if (!!rewardExists) {
+                rewardToUpdate.push({
+                    recipient: point.recipient,
+                    pending: BigInt(rewardExists.pending) + BigInt(point.pendingIncrease),
+                });
+            }
+            else {
+                rewardToCreate.push({
+                    recipient: point.recipient,
+                    pending: BigInt(point.pendingIncrease),
+                });
+            }
+        }
+    }
+    const totalRewardIncrease = Object.values(rewardIdToPendingIncrease).reduce((prev, current) => prev + BigInt(current.pendingIncrease), 0n);
+    log.info(`total increase: ${totalRewardIncrease.toString()}, rewards to create:    ${rewardToCreate.length}, to update: ${rewardToUpdate.length}`);
+    log.info(`total increase: ${totalBreakdownIncrease.toString()}, breakdowns to create: ${breakdownToCreate.length}, to update: ${breakdownToUpdate.length}`);
+    if (rewardToCreate.length > 0) {
+        const users = rewardToCreate.map(x => x.recipient);
+        await apiDbClient.user.createMany({ data: users.map(x => ({ address: x, tags: [] })), skipDuplicates: true });
+        await apiDbClient.reward.createMany({
+            data: rewardToCreate.map(x => {
+                const rewardId = Bun.hash(`${root}${x.recipient}${rewardTokenId}`).toString();
+                return {
+                    id: rewardId,
+                    root,
+                    recipient: x.recipient,
+                    rewardTokenId,
+                    proofs: [],
+                    amount: "0",
+                    pending: x.pending.toString(),
+                    claimed: "0",
+                };
+            }),
+        });
+    }
+    if (breakdownToCreate.length > 0) {
+        await apiDbClient.rewardBreakdown.createMany({
+            data: breakdownToCreate.map(x => {
+                const rewardId = Bun.hash(`${root}${x.recipient}${rewardTokenId}`).toString();
+                return {
+                    reason: x.reason,
+                    amount: "0",
+                    pending: x.pending,
+                    claimed: "0",
+                    rewardId,
+                    campaignId,
+                };
+            }),
+        });
+    }
+    if (breakdownToUpdate.length > 0) {
+        await apiDbClient.$transaction(breakdownToUpdate.map(x => {
+            return apiDbClient.rewardBreakdown.update({
+                where: {
+                    rewardId_campaignId_reason: {
+                        rewardId: Bun.hash(`${root}${x.recipient}${rewardTokenId}`).toString(),
+                        campaignId: campaignId,
+                        reason: x.reason,
+                    },
+                },
+                data: {
+                    pending: x.pending,
+                },
+            });
+        }));
+    }
+    if (rewardToUpdate.length > 0) {
+        await apiDbClient.$transaction(rewardToUpdate.map(x => {
+            const rewardId = Bun.hash(`${data.root}${x.recipient}${rewardTokenId}`).toString();
+            return apiDbClient.reward.update({
+                where: {
+                    id: rewardId,
+                },
+                data: {
+                    pending: x.pending.toString(),
+                },
+            });
+        }));
+    }
+    return { created: breakdownToCreate.length, updated: breakdownToUpdate.length };
+};
+// ─────────────────────────────────────────────────────────────────────────────
+export const main = async () => {
+    log.info(`✅ Running for ${process.env.FILENAME}`);
+    const start = moment().unix();
+    // ─── Start Rewards ETL ───────────────────────────────────────────────
+    const { created, updated, failed, batch } = await extract();
+    log.info(`✅ Successfully created ${created} and updated ${updated} pendings records in ${batch} batches for ${process.env.FILENAME} in ${moment().unix() - start} sec`);
+    if (failed !== 0) {
+        log.error("pendings", `${failed} batches failed.`);
+        process.exit(1);
+    }
+    if (failed === 0) {
+        await file.delete();
+    }
+};
+main();

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

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

package/dist/src/jobs/prices.js

@@ -0,0 +1,10 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { log } from "@/utils/logger";
+import { Pricer } from "@/utils/pricer";
+const pricer = await Pricer.load();
+const prices = await pricer.update();
+log.info(`✅ ${Object.keys(prices).length} prices cache updated successfully`);
+log.info("⏳ Updating API database...");
+await TokenService.updatePrices(pricer);
+log.info("✅ API database updated successfully!");
+process.exit(0);

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

@@ -0,0 +1 @@
+export declare const main: () => Promise<void>;

package/dist/src/jobs/reward-breakdowns.js

@@ -0,0 +1,152 @@
+// ─── Reward Breakdowns ETL ───────────────────────────────────────────────────
+if (!process.env.DATABASE_API_URL || !process.env.ENV || !process.env.CHAIN_ID || !process.env.ROOT)
+    throw new Error("[ENV]: missing variable");
+import { BucketService } from "@/modules/v4/bucket/bucket.service";
+import { log } from "@/utils/logger";
+import { apiDbClient } from "@db";
+import { S3Client } from "bun";
+import moment from "moment";
+// ─── Global Variables ────────────────────────────────────────
+const gcsClient = new S3Client({
+    accessKeyId: process.env.GCS_ACCESS_ID,
+    secretAccessKey: process.env.GCS_SECRET,
+    endpoint: process.env.GCS_ENDPOINT,
+    bucket: `merkl-rewards-lake-${process.env.ENV}`,
+});
+const file = gcsClient.file(`breakdowns/${process.env.CHAIN_ID}-${process.env.ROOT}`);
+const failedBatches = [];
+const missingCampaigns = [];
+// ─── Extract ─────────────────────────────────────────────────────────────────
+const extract = async () => {
+    if (!file.exists())
+        throw new Error("File does not exist.");
+    let data = [];
+    const textDecoder = new TextDecoder();
+    let buffer = "";
+    const stream = file.stream();
+    let count = 0;
+    for await (const chunk of stream) {
+        buffer += textDecoder.decode(chunk);
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            if (line.trim())
+                data.push(...(await transform(JSON.parse(line))));
+        }
+        if (data.length < 30_000)
+            continue;
+        try {
+            count += await load(data);
+            data = [];
+        }
+        catch (err) {
+            // log.error("Failed to insert a batch, adding it to the fail queue.", err);
+            failedBatches.push(data);
+            data = [];
+        }
+    }
+    try {
+        count += await load(data);
+        data = [];
+    }
+    catch (err) {
+        // log.error("Failed to insert a batch, adding it to the fail queue.", err);
+        failedBatches.push(data);
+        data = [];
+    }
+    return count;
+};
+// ─── Transform ───────────────────────────────────────────────────────────────
+const transform = (rewardBreakdowns) => {
+    const transformedBreakdowns = Array(rewardBreakdowns.length);
+    let i = 0;
+    for (i; i < rewardBreakdowns.length; i++) {
+        const rewardTokenId = Bun.hash(`${process.env.CHAIN_ID}${rewardBreakdowns[i].token}`).toString();
+        const rewardId = Bun.hash(`${process.env.ROOT}${rewardBreakdowns[i].recipient}${rewardTokenId}`).toString();
+        const campaignId = Bun.hash(`${process.env.CHAIN_ID}${rewardBreakdowns[i].campaignId}`).toString();
+        transformedBreakdowns[i] = {
+            rewardId,
+            protocolId: rewardBreakdowns[i].protocolId ? rewardBreakdowns[i].protocolId : undefined,
+            campaignId,
+            reason: rewardBreakdowns[i].reason ? rewardBreakdowns[i].reason : "",
+            amount: rewardBreakdowns[i].amount,
+            claimed: rewardBreakdowns[i].claimed,
+            pending: rewardBreakdowns[i].pending,
+            merklCampaignId: rewardBreakdowns[i].campaignId,
+        };
+    }
+    return transformedBreakdowns;
+};
+// ─── Load ────────────────────────────────────────────────────────────────────
+const load = async (rewardBreakdowns) => {
+    const count = (await apiDbClient.rewardBreakdown.createMany({
+        data: rewardBreakdowns.map(breakdown => ({
+            id: breakdown.id,
+            protocolId: breakdown.protocolId,
+            reason: breakdown.reason,
+            amount: breakdown.amount,
+            claimed: breakdown.claimed,
+            pending: breakdown.pending,
+            rewardId: breakdown.rewardId,
+            campaignId: breakdown.campaignId,
+        })),
+        skipDuplicates: true,
+    })).count;
+    log.info(`Successfully inserted ${rewardBreakdowns.length} reward breakdown(s).`);
+    return count;
+};
+// ─── Retry ───────────────────────────────────────────────────────────────────
+// Using binary search
+const retry = async (batches) => {
+    log.info(`Retrying ${batches.length} batch(es)...`);
+    let inserted = 0;
+    while (batches.length > 0) {
+        const currentBatch = batches.shift();
+        const firstHalf = currentBatch.splice(0, Math.ceil(currentBatch.length / 2));
+        const secondHalf = currentBatch;
+        // Process first half
+        try {
+            inserted += await load(firstHalf);
+        }
+        catch (err) {
+            log.error(JSON.stringify(firstHalf), err);
+            if (firstHalf.length > 1)
+                batches.push(firstHalf);
+            else
+                missingCampaigns.push(firstHalf[0].merklCampaignId);
+        }
+        // Process second half
+        try {
+            inserted += await load(secondHalf);
+        }
+        catch (err) {
+            log.error(JSON.stringify(secondHalf), err);
+            if (secondHalf.length > 1)
+                batches.push(secondHalf);
+            else
+                missingCampaigns.push(secondHalf[0].merklCampaignId);
+        }
+    }
+    return inserted;
+};
+// ─── Main ────────────────────────────────────────────────────────────────────
+export const main = async () => {
+    const start = moment().unix();
+    const count = await extract();
+    log.info(`✅ Successfully created ${count} new record(s) for ${process.env.CHAIN_ID}-${process.env.ROOT} in ${moment().unix() - start} sec.`);
+    if (failedBatches.length !== 0) {
+        const inserted = await retry(failedBatches);
+        log.info(`Successfully inserted ${inserted} record(s) after retrying.`);
+        if (inserted !== failedBatches.length) {
+            log.error("breakdowns", `${failedBatches.length} breakdown(s) failed to insert.`);
+            // ─── Push Missing Campaigns To Bucket ────────────────
+            const bucket = new BucketService(`merkl-campaigns-lake-${process.env.ENV}`, `merkl-data-${process.env.ENV}`);
+            await bucket.push(`${process.env.CHAIN_ID}_missing_campaigns.json`, JSON.stringify(missingCampaigns), {
+                type: "application/json",
+            });
+            process.exit(1);
+        }
+    }
+    // if (failedBatches.length === 0) await file.delete();
+};
+main();

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

@@ -0,0 +1 @@
+export declare const main: () => Promise<void>;

package/dist/src/jobs/rewards.js

@@ -0,0 +1,112 @@
+// ─── Rewards ETL ─────────────────────────────────────────────────────────────
+if (!process.env.ENV || !process.env.CHAIN_ID || !process.env.ROOT)
+    throw new Error("[ENV]: missing variable");
+import { log } from "@/utils/logger";
+import { apiDbClient } from "@db";
+import { withRetry } from "@sdk";
+import { S3Client } from "bun";
+import moment from "moment";
+// ─── Global Variables ────────────────────────────────────────
+const gcsClient = new S3Client({
+    accessKeyId: process.env.GCS_ACCESS_ID,
+    secretAccessKey: process.env.GCS_SECRET,
+    endpoint: process.env.GCS_ENDPOINT,
+    bucket: `merkl-rewards-lake-${process.env.ENV}`,
+});
+let file = gcsClient.file(`rewards/${process.env.CHAIN_ID}-${process.env.ROOT}`);
+if (!(await file.exists()))
+    file = gcsClient.file(`rewards/${process.env.CHAIN_ID}-${process.env.ROOT}.gz`);
+if (!(await file.exists())) {
+    log.error("rewards", "File does not exist.");
+    process.exit(0);
+}
+const failedBatches = [];
+// ─── Extract ─────────────────────────────────────────────────────────────────
+const extract = async () => {
+    if (!file.exists())
+        throw new Error("File does not exist.");
+    const data = [];
+    const textDecoder = new TextDecoder();
+    let buffer = "";
+    const stream = file.stream();
+    let count = 0;
+    for await (const chunk of stream) {
+        buffer += textDecoder.decode(chunk);
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            if (line.trim())
+                data.push(transform(JSON.parse(line)));
+        }
+        try {
+            count += await withRetry(load, [data], 5, 60_000);
+            data.length = 0;
+        }
+        catch (err) {
+            console.error(`Failed to insert a batch, adding it to the fail queue.\n${err}`);
+            failedBatches.push(data);
+            data.length = 0;
+        }
+    }
+    return count;
+};
+// ─── Transform ───────────────────────────────────────────────────────────────
+const transform = (reward) => {
+    const rewardTokenId = Bun.hash(`${process.env.CHAIN_ID}${reward.rewardToken}`).toString();
+    const id = Bun.hash(`${process.env.ROOT}${reward.recipient}${rewardTokenId}`).toString();
+    return {
+        id,
+        root: reward.root,
+        amount: reward.amount,
+        pending: reward.pending,
+        claimed: reward.claimed,
+        recipient: reward.recipient,
+        rewardTokenId,
+        proofs: reward.proofs,
+    };
+};
+// ─── Load ────────────────────────────────────────────────────────────────────
+const load = async (rewards) => {
+    // ─── Load Users ──────────────────────────────────────────────────────
+    await apiDbClient.user.createMany({
+        data: rewards.map(r => {
+            return {
+                address: r.recipient,
+            };
+        }),
+        skipDuplicates: true,
+    });
+    // ─── Load Rewards ────────────────────────────────────────────────────
+    return (await apiDbClient.reward.createMany({
+        data: rewards,
+        skipDuplicates: true,
+    })).count;
+};
+// ─────────────────────────────────────────────────────────────────────────────
+export const main = async () => {
+    const start = moment().unix();
+    // ─── Create Merkle Root If Not Exists ────────────────────────────────
+    await apiDbClient.merklRoot.upsert({
+        create: {
+            root: process.env.ROOT,
+            chainId: +process.env.CHAIN_ID,
+            epoch: Math.floor(start / 3_600),
+            timestamp: start,
+        },
+        update: {},
+        where: {
+            root: process.env.ROOT,
+        },
+    });
+    // ─── Start Rewards ETL ───────────────────────────────────────────────
+    const count = await extract();
+    log.info(`✅ Successfully created ${count} new records for ${process.env.CHAIN_ID}-${process.env.ROOT} in ${moment().unix() - start} sec`);
+    if (failedBatches.length !== 0) {
+        log.error("rewards", `${failedBatches.length} batches failed.`);
+        process.exit(1);
+    }
+    if (failedBatches.length === 0) {
+        // await file.delete();
+    }
+};
+main();

package/dist/src/jobs/set-dungeon-keeper.d.ts

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