@merkl/api 0.21.46 → 1.0.0

package/dist/src/modules/v4/reward/reward.model.js

@@ -1,153 +0,0 @@
-import { t } from "elysia";
-import { TokenResourceDto } from "../token/token.model";
-// ─── DTOs ────────────────────────────────────────────────────────────────────
-export const DailyRewardsBreakdownRecordResourceDto = t.Object({
-    id: t.String(),
-    campaignId: t.String(),
-    value: t.Number(),
-    dailyRewardsRecordId: t.String(),
-    token: TokenResourceDto,
-    amount: t.Union([t.BigInt(), t.String()]),
-});
-export const DailyRewardsRecordResourceDto = t.Object({
-    id: t.String(),
-    total: t.Number(),
-    timestamp: t.Union([t.BigInt(), t.String()]),
-    breakdowns: t.Array(DailyRewardsBreakdownRecordResourceDto),
-});
-const BreakdownDto = t.Object({
-    recipient: t.String(),
-    protocolId: t.Optional(t.String()),
-    reason: t.String(),
-    amount: t.String(),
-    claimed: t.String(),
-    pending: t.String(),
-});
-export const CreateManyBreakdownDto = t.Array(t.Object({
-    distributionChainId: t.Numeric(),
-    rewardToken: t.String(),
-    campaignId: t.String(),
-    root: t.String(),
-    breakdowns: t.Array(BreakdownDto),
-}));
-const RewardDto = t.Object({
-    root: t.String(),
-    recipient: t.String(),
-    distributionChainId: t.Number(),
-    rewardToken: t.String(),
-    amount: t.String(),
-    claimed: t.String(),
-    pending: t.String(),
-    proofs: t.Array(t.String()),
-});
-export const CreateManyRewardDto = t.Array(RewardDto);
-export const RegisterClaimsDto = t.Array(t.Object({
-    chainId: t.Numeric(),
-    recipient: t.String(),
-    token: t.String(),
-    root: t.String(),
-}));
-const PendingDto = t.Object({
-    recipient: t.String(),
-    reason: t.String(),
-    pending: t.String(),
-});
-export const UpdatePendingDto = t.Object({
-    distributionChainId: t.Numeric(),
-    rewardToken: t.String(),
-    campaignId: t.String(),
-    root: t.String(),
-    data: t.Array(PendingDto),
-});
-export const RewardsByUser = t.Object({
-    address: t.String(),
-});
-export const RewardsByUserAndChain = t.Object({
-    address: t.String(),
-    chainId: t.Numeric(),
-});
-export const UserRewardQueryDto = t.Object({
-    chainId: t.Numeric(),
-    mainParameter: t.Optional(t.String()),
-    proof: t.Optional(t.String()),
-    rewardToken: t.Optional(t.String()),
-    user: t.String(),
-});
-export const RewardsPerChainDto = t.Object({
-    chainId: t.Numeric(),
-});
-export const CampaignIdWithoutPageDto = t.Object({
-    chainId: t.Numeric({
-        description: "Chain ID",
-    }),
-    campaignIds: t
-        .Transform(t.Union([
-        t.String({
-            description: "Comma-separated campaign IDs",
-        }),
-        t.Array(t.String()),
-    ]))
-        .Decode(value => {
-        return typeof value === "string" ? value.split(",") : value;
-    })
-        .Encode(value => [...value]),
-});
-export const CampaignIdDto = t.Object({
-    chainId: t.Numeric({
-        description: "Chain ID",
-    }),
-    campaignId: t.String({
-        description: "Campaign ID",
-    }),
-    page: t.Optional(t.Numeric({ description: "Page number", default: 0 })), // 0-indexed
-    items: t.Optional(t.Numeric({ description: "Number of returned rows", default: 20 })), // items per page
-});
-export const TokenIdDto = t.Object({
-    chainId: t.Numeric({
-        description: "Chain ID",
-    }),
-    address: t.String({
-        description: "Token Address",
-    }),
-    campaignIds: t.Optional(t.Array(t.String())),
-    page: t.Optional(t.Numeric({ description: "Page number", default: 0 })), // 0-indexed
-    items: t.Optional(t.Numeric({ description: "Number of returned rows", default: 20 })), // items per page
-});
-export const CampaignRewardsDto = t.Object({
-    page: t.Optional(t.Numeric({ description: "Page number", default: 0 })), // 0-indexed
-    items: t.Optional(t.Numeric({ description: "Number of returned rows", default: 20 })), // items per page
-});
-export const UserRewardV3Dto = t.Record(t.String({ title: "TokenAddress" }), t.Object({
-    symbol: t.String(),
-    decimals: t.Number(),
-    accumulated: t.String(),
-    unclaimed: t.String(),
-    pending: t.Optional(t.String()),
-    reasons: t.Record(t.String({ title: "Reason" }), t.Object({ accumulated: t.String(), unclaimed: t.String(), pending: t.Optional(t.String()) })),
-    proof: t.Optional(t.Array(t.String())),
-}));
-export const RewardV3Dto = t.Record(t.String({ title: "Chain" }), t.Object({
-    campaignData: t.Record(t.String({ title: "CampaignId" }), t.Record(t.String({ title: "reason" }), t.Object({
-        accumulated: t.String(),
-        unclaimed: t.String(),
-        pending: t.Optional(t.String()),
-        decimals: t.Numeric(),
-        mainParameter: t.String(),
-        symbol: t.String(),
-        token: t.String(),
-    }))),
-    tokenData: t.Record(t.String(), t.Object({
-        accumulated: t.String(),
-        unclaimed: t.String(),
-        pending: t.Optional(t.String()),
-        decimals: t.Numeric(),
-        proof: t.Array(t.String()),
-        symbol: t.String(),
-    })),
-}), { $id: "Rewards", additionalProperties: true });
-export const QueryTotalDailyRewardsSinceDto = t.Object({
-    since: t.Date(),
-    chainId: t.Optional(t.Numeric()),
-    protocol: t.Optional(t.String()),
-    type: t.Optional(t.String()),
-});

package/dist/src/modules/v4/reward/reward.repository.js

@@ -1,350 +0,0 @@
-import { Campaign, Reward, RewardBreakdown } from "@db/api:drizzle";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { UserService } from "@/modules/v4/user/user.service";
-import { apiDbClient } from "@db";
-import { DAY } from "@sdk";
-import { and, eq, exists, inArray, sql } from "drizzle-orm";
-import { RewardService } from "./reward.service";
-export class RewardRepository {
-    static async createManyReward(rewards) {
-        const users = rewards.map(reward => {
-            return {
-                address: reward.recipient,
-                tags: [],
-            };
-        });
-        await UserService.createMany(users);
-        const rewardsToCreate = rewards.map(reward => {
-            const rewardTokenId = TokenService.hashId({ address: reward.rewardToken, chainId: reward.distributionChainId });
-            return {
-                id: RewardService.hashId(reward.root, reward.recipient, rewardTokenId),
-                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,
-        });
-    }
-    static async createManyBreakdown(data) {
-        const breakdownsToCreate = [];
-        for (const dataPerCampaign of data) {
-            const campaignId = CampaignService.hashId({
-                distributionChain: dataPerCampaign.distributionChainId,
-                campaignId: dataPerCampaign.campaignId,
-            });
-            dataPerCampaign.breakdowns.map(breakdown => {
-                const rewardId = RewardService.hashId(dataPerCampaign.root, breakdown.recipient, TokenService.hashId({ address: dataPerCampaign.rewardToken, chainId: dataPerCampaign.distributionChainId }));
-                breakdownsToCreate.push({
-                    rewardId,
-                    protocolId: breakdown.protocolId ? breakdown.protocolId : undefined,
-                    campaignId,
-                    reason: breakdown.reason ? breakdown.reason : "",
-                    amount: breakdown.amount,
-                    claimed: breakdown.claimed,
-                    pending: breakdown.pending,
-                });
-            });
-        }
-        return await apiDbClient.rewardBreakdown.createMany({
-            data: breakdownsToCreate,
-        });
-    }
-    static async getByRecipient(recipient, roots, withToken, withTestTokens, chainFilter, reasonFilter) {
-        return await apiDbClient.reward.findMany({
-            where: {
-                root: {
-                    in: roots,
-                },
-                recipient,
-                RewardToken: !!chainFilter?.length || !withTestTokens
-                    ? {
-                        chainId: !!chainFilter?.length ? { in: chainFilter } : undefined,
-                        isTest: withTestTokens ? undefined : false,
-                    }
-                    : undefined,
-                Breakdown: reasonFilter
-                    ? {
-                        some: {
-                            reason: {
-                                contains: reasonFilter,
-                                mode: "insensitive",
-                            },
-                        },
-                    }
-                    : undefined,
-            },
-            include: {
-                Breakdown: {
-                    where: reasonFilter
-                        ? {
-                            reason: {
-                                contains: reasonFilter,
-                                mode: "insensitive",
-                            },
-                        }
-                        : undefined,
-                    include: {
-                        Campaign: {
-                            select: {
-                                campaignId: true,
-                                Opportunity: {
-                                    include: {
-                                        MainProtocol: true,
-                                        Chain: true,
-                                        Protocols: true,
-                                        Tokens: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                RewardToken: withToken
-                    ? true
-                    : {
-                        select: { address: true, chainId: true, symbol: true, decimals: true, price: true },
-                    },
-            },
-        });
-    }
-    static async getByChainRecipientToken(recipient, root, tokenId) {
-        return await apiDbClient.reward.findUnique({
-            where: {
-                root_recipient_rewardTokenId: {
-                    root,
-                    recipient,
-                    rewardTokenId: tokenId,
-                },
-            },
-            include: {
-                Breakdown: {
-                    include: {
-                        Campaign: {
-                            select: { campaignId: true },
-                        },
-                    },
-                },
-            },
-        });
-    }
-    static async countRewardAndBreakdownOnChain(chainId, root) {
-        const rewardCount = await apiDbClient.reward.count({
-            where: {
-                root,
-                RewardToken: {
-                    chainId,
-                },
-            },
-        });
-        const breakdownCount = await apiDbClient.rewardBreakdown.count({
-            where: {
-                Reward: {
-                    root,
-                    RewardToken: {
-                        chainId,
-                    },
-                },
-            },
-        });
-        return { rewardCount, breakdownCount };
-    }
-    static async updateRewardClaimed(recipient, rewardTokenId, amount) {
-        return await apiDbClient.reward.updateMany({
-            where: {
-                recipient,
-                rewardTokenId,
-            },
-            data: {
-                claimed: amount,
-            },
-        });
-    }
-    static async updateBreakdownClaimed(recipient, rewardTokenId, campaignId, reason, amount) {
-        return await apiDbClient.rewardBreakdown.updateMany({
-            where: {
-                campaignId,
-                reason,
-                Reward: {
-                    recipient,
-                    rewardTokenId,
-                },
-            },
-            data: {
-                claimed: amount,
-            },
-        });
-    }
-    static async findManyRootsWithRewardOnChain(chainId) {
-        return (await apiDbClient.merklRoot.findMany({
-            where: {
-                chainId: chainId,
-                Rewards: {
-                    some: {},
-                },
-            },
-            select: {
-                root: true,
-            },
-        })).map(x => x.root);
-    }
-    static async breakdownForCampaign(root, id, query) {
-        const { page: _page, items: _items } = query;
-        const page = _page || 0;
-        const items = _items || 50;
-        const result = await apiDbClient.$queryRawUnsafe(`
-      SELECT 
-        rb."amount",
-        rb."reason",
-        rb."claimed",
-        rb."pending",
-        r."recipient",
-        t."address" as "rewardTokenAddress"
-      FROM 
-        "RewardBreakdown" rb
-      INNER JOIN 
-        "Reward" r ON rb."rewardId" = r."id"
-      INNER JOIN 
-        "Token" t ON r."rewardTokenId" = t."id"
-      WHERE 
-        r."root" = $1 AND rb."campaignId" = $2
-      ORDER BY 
-        (rb."amount"::numeric + rb."pending"::numeric) DESC
-      LIMIT $3
-      OFFSET $4
-    `, root, id, items, items * page);
-        return result;
-    }
-    static async totalForCampaign(campaignId, root) {
-        const totalAmount = await apiDbClient.rewardBreakdown.findMany({
-            where: {
-                campaignId,
-                Reward: {
-                    root,
-                },
-            },
-            select: {
-                amount: true,
-                pending: true,
-                campaignId: true,
-            },
-        });
-        const reducedData = totalAmount.reduce((acc, { amount, pending }) => {
-            acc.amount += BigInt(amount) + BigInt(pending ?? 0);
-            return acc;
-        }, { campaignId, amount: 0n });
-        return reducedData;
-    }
-    static async countForCampaign(campaignId, root) {
-        const count = await apiDbClient.rewardBreakdown.count({
-            where: {
-                campaignId,
-                Reward: {
-                    root,
-                },
-            },
-        });
-        return { count };
-    }
-    static async breakdownForToken(root, id, query) {
-        const { page: _page, items: _items, campaignIds } = query;
-        const page = _page || 0;
-        const items = _items || 50;
-        const ids = typeof campaignIds === "string"
-            ? campaignIds === "[]"
-                ? []
-                : [campaignIds]
-            : campaignIds?.some(c => c === "[]")
-                ? []
-                : (campaignIds ?? []);
-        const result = await apiDbClient.$drizzle
-            .select({ amount: Reward.amount, claimed: Reward.claimed, pending: Reward.pending, recipient: Reward.recipient })
-            .from(Reward)
-            .where(and(eq(Reward.root, root), eq(Reward.rewardTokenId, id), ids.length > 0
-            ? exists(apiDbClient.$drizzle
-                .select()
-                .from(RewardBreakdown)
-                .innerJoin(Campaign, eq(RewardBreakdown.campaignId, Campaign.id))
-                .where(and(eq(RewardBreakdown.rewardId, Reward.id), inArray(Campaign.campaignId, ids))))
-            : sql `TRUE`))
-            .orderBy(sql `(${Reward.amount}::numeric + ${Reward.pending}::numeric) desc`)
-            .limit(items)
-            .offset(items * page);
-        return result;
-    }
-    static async totalForToken(tokenId, root) {
-        const totalAmount = await apiDbClient.reward.findMany({
-            where: {
-                rewardTokenId: tokenId,
-                root,
-            },
-            select: {
-                amount: true,
-                pending: true,
-            },
-        });
-        const reducedData = totalAmount.reduce((acc, { amount, pending }) => {
-            acc.amount += BigInt(amount) + BigInt(pending ?? 0);
-            return acc;
-        }, { tokenId, amount: 0n });
-        return reducedData;
-    }
-    static async countForToken(tokenId, root) {
-        const count = await apiDbClient.reward.count({
-            where: {
-                rewardTokenId: tokenId,
-                root,
-            },
-        });
-        return { count };
-    }
-    static async getAmountAndClaimedForCampaigns(root, x) {
-        return await apiDbClient.rewardBreakdown.findMany({
-            select: {
-                claimed: true,
-                amount: true,
-                campaignId: true,
-            },
-            where: {
-                campaignId: {
-                    in: x.campaignIds.map(campaignId => CampaignService.hashId({ distributionChain: x.chainId, campaignId })),
-                },
-                Reward: {
-                    root,
-                },
-            },
-        });
-    }
-    /**
-     * Calculates the sum of daily average rewards for a given opportunity since a specified timestamp.
-     *
-     * @param since - The timestamp (in seconds) from which to start calculating the rewards.
-     * @param opportunityId - The ID of the opportunity for which to calculate the rewards.
-     * @returns The sum of daily average rewards for the specified opportunity since the given timestamp.
-     */
-    static async sumDailyRewardsAvgByOpportunity(since, opportunityId) {
-        const dateToRewards = new Map();
-        const dailyAvg = [];
-        const records = await apiDbClient.dailyRewardsRecord.findMany({
-            where: { opportunityId, timestamp: { gte: since }, total: { gt: 0 } },
-            select: { timestamp: true, total: true },
-        });
-        if (records.length === 0)
-            return 0;
-        for (const record of records) {
-            const date = Math.floor(Number(record.timestamp) / DAY).toString();
-            const rewards = dateToRewards.get(date) ?? [];
-            rewards.push(record.total);
-            dateToRewards.set(date, rewards);
-        }
-        for (const rewards of dateToRewards.values())
-            dailyAvg.push(rewards.reduce((prev, curr) => prev + curr, 0) / rewards.length);
-        return dailyAvg.reduce((prev, curr) => prev + curr, 0);
-    }
-}