@merkl/api 0.19.35 → 0.19.37

package/dist/src/modules/v4/reward/reward.service.d.ts

@@ -8,6 +8,171 @@ export declare abstract class RewardService {
     static hashId(root: string, recipient: string, rewardTokenId: string): string;
     static hashDailyRewardsRecordId(opportunityId: string, timestamp: bigint): string;
     static createManyReward(rewards: CreateManyRewardModel): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    static getTotalDistributedByOpportunities(since: number): Promise<Map<{
+        apr: number;
+        aprRecord: {
+            cumulated: number;
+            timestamp: bigint;
+            breakdowns: {
+                id: number;
+                type: import("@db/api").$Enums.AprType;
+                identifier: string;
+                value: number;
+                aprRecordId: string;
+            }[];
+        };
+        tvlRecord: {
+            id: string;
+            total: number;
+            timestamp: bigint;
+            breakdowns: {
+                id: number;
+                type: import("@db/api").$Enums.TvlType;
+                identifier: string;
+                value: number;
+                tvlRecordId: string;
+            }[];
+        };
+        rewardsRecord: {
+            id: string;
+            total: number;
+            timestamp: bigint;
+            breakdowns: {
+                id: number;
+                value: number;
+                campaignId: string;
+                dailyRewardsRecordId: string;
+                token: {
+                    symbol: string;
+                    id: string;
+                    name: string | null;
+                    icon: string;
+                    address: string;
+                    chainId: number;
+                    decimals: number;
+                    displaySymbol: string;
+                    verified: boolean;
+                    isTest: boolean;
+                    isPoint: boolean;
+                    isNative: boolean;
+                    price: number | null;
+                };
+                amount: bigint;
+            }[];
+        };
+        campaigns: {
+            params: any;
+            chain: {
+                id: number;
+                name: string;
+                icon: string;
+            };
+            endTimestamp: number;
+            startTimestamp: number;
+            rewardToken: {
+                symbol: string;
+                id: string;
+                name: string | null;
+                icon: string;
+                address: string;
+                chainId: number;
+                decimals: number;
+                verified: boolean;
+                isTest: boolean;
+                isPoint: boolean;
+                isNative: boolean;
+            } & {
+                price?: number | null | undefined;
+            };
+            distributionChain: {
+                id: number;
+                name: string;
+                icon: string;
+            } | undefined;
+            campaignStatus: {
+                computedUntil: number;
+                processingStarted: number;
+                error: string;
+                status: import("@db/api").$Enums.RunStatus;
+                details: import("database/api/.generated/runtime/library").JsonValue;
+                campaignId: string;
+            } | undefined;
+            creatorAddress: string;
+            creator: {
+                tags: string[];
+                address: string;
+                creatorId: string | null;
+            };
+            createdAt: string;
+            Opportunity: {
+                id: string;
+                name: string;
+                type: string;
+                status: import("@db/api").$Enums.Status;
+                tags: string[];
+                identifier: string;
+                action: import("@db/api").$Enums.OpportunityAction;
+                chainId: number;
+                depositUrl: string | null;
+                mainProtocolId: string | null;
+                tvl: number;
+                apr: number;
+                dailyRewards: number;
+            };
+            id: string;
+            type: string;
+            subType: number | null;
+            computeChainId: number;
+            distributionChainId: number;
+            campaignId: string;
+            rewardTokenId: string;
+            amount: string;
+            opportunityId: string;
+        }[] | undefined;
+        id: string;
+        depositUrl: string | undefined;
+        tokens: ({
+            symbol: string;
+            id: string;
+            name: string | null;
+            icon: string;
+            address: string;
+            chainId: number;
+            decimals: number;
+            verified: boolean;
+            isTest: boolean;
+            isPoint: boolean;
+            isNative: boolean;
+        } & {
+            price?: number | null | undefined;
+        })[];
+        chain: {
+            id: number;
+            name: string;
+            icon: string;
+        };
+        protocol: {
+            id: string;
+            name: string;
+            url: string;
+            description: string;
+            tags: string[];
+            icon: string;
+        } | undefined;
+        name: string;
+        type: string;
+        status: import("@db/api").$Enums.Status;
+        tags: string[];
+        identifier: string;
+        action: import("@db/api").$Enums.OpportunityAction;
+        chainId: number;
+        tvl: number;
+        dailyRewards: number;
+    }, number>>;
+    static getTotalDistributed(since: number): Promise<number>;
+    static getTotalDistributedByChains(since: number): Promise<any>;
+    static getTotalDistributedByProtocol(since: number): Promise<any>;
+    static getTotalDistributedByType(since: number): Promise<any>;
     /**
      * Format the reward breakdown to conform to its resource model declaration
      * @param breakdown straight from db

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

@@ -20,6 +20,56 @@ export class RewardService {
     static async createManyReward(rewards) {
         return await RewardRepository.createManyReward(rewards);
     }
+    static async getTotalDistributedByOpportunities(since) {
+        const opportunities = await OpportunityService.findMany({ items: 0 });
+        const promiseArray = [];
+        let i = 0;
+        const oppToDailyRewards = new Map();
+        for (i = 0; i < opportunities.length; i++) {
+            promiseArray.push(RewardRepository.sumDailyRewardsAvgByOpportunity(since, opportunities[i].id));
+        }
+        const result = await Promise.all(promiseArray);
+        i = 0;
+        for (i = 0; i < result.length; i++) {
+            // need an upper threshold bc certain opportunities have crazy daily rewards (cf. vicuna)
+            if (result[i] !== null && result[i] > 0 && result[i] <= 1_000_000_000)
+                oppToDailyRewards.set(opportunities[i], result[i]);
+        }
+        return oppToDailyRewards;
+    }
+    static async getTotalDistributed(since) {
+        const oppToDailyRewards = await RewardService.getTotalDistributedByOpportunities(since);
+        return oppToDailyRewards.values().reduce((prev, curr) => prev + curr, 0);
+    }
+    static async getTotalDistributedByChains(since) {
+        const oppToDailyRewards = await RewardService.getTotalDistributedByOpportunities(since);
+        const chainsToDailyRewards = new Map();
+        for (const [opp, dr] of oppToDailyRewards.entries()) {
+            const dailyRewards = chainsToDailyRewards.get(opp.chainId) === undefined ? dr : chainsToDailyRewards.get(opp.chainId) + dr;
+            chainsToDailyRewards.set(opp.chainId, dailyRewards);
+        }
+        return Object.fromEntries(chainsToDailyRewards);
+    }
+    static async getTotalDistributedByProtocol(since) {
+        const oppToDailyRewards = await RewardService.getTotalDistributedByOpportunities(since);
+        const protocolToDailyRewards = new Map();
+        for (const [opp, dr] of oppToDailyRewards.entries()) {
+            const dailyRewards = protocolToDailyRewards.get(opp.protocol?.id) === undefined
+                ? dr
+                : protocolToDailyRewards.get(opp.protocol?.id) + dr;
+            protocolToDailyRewards.set(opp.protocol?.id, dailyRewards);
+        }
+        return Object.fromEntries(protocolToDailyRewards);
+    }
+    static async getTotalDistributedByType(since) {
+        const oppToDailyRewards = await RewardService.getTotalDistributedByOpportunities(since);
+        const typeToDailyRewards = new Map();
+        for (const [opp, dr] of oppToDailyRewards.entries()) {
+            const dailyRewards = typeToDailyRewards.get(opp.type) === undefined ? dr : typeToDailyRewards.get(opp.type) + dr;
+            typeToDailyRewards.set(opp.type, dailyRewards);
+        }
+        return Object.fromEntries(typeToDailyRewards);
+    }
     /**
      * Format the reward breakdown to conform to its resource model declaration
      * @param breakdown straight from db

package/dist/src/modules/v4/router.d.ts

@@ -1622,7 +1622,9 @@ export declare const v4: Elysia<"/v4", false, {
                         withOpportunity?: boolean | undefined;
                         createdAfter?: Date | null | undefined;
                     };
-                    headers: unknown;
+                    headers: {
+                        authorization: string;
+                    };
                     response: {
                         200: {
                             [x: string]: number;
@@ -1634,7 +1636,7 @@ export declare const v4: Elysia<"/v4", false, {
     } & {
         campaigns: {
             count: {
-                "by-type": {
+                "by-types": {
                     get: {
                         body: unknown;
                         params: {};
@@ -1662,7 +1664,9 @@ export declare const v4: Elysia<"/v4", false, {
                             withOpportunity?: boolean | undefined;
                             createdAfter?: Date | null | undefined;
                         };
-                        headers: unknown;
+                        headers: {
+                            authorization: string;
+                        };
                         response: {
                             200: {
                                 [x: string]: number;
@@ -1675,7 +1679,7 @@ export declare const v4: Elysia<"/v4", false, {
     } & {
         campaigns: {
             count: {
-                "by-protocol": {
+                "by-protocols": {
                     get: {
                         body: unknown;
                         params: {};
@@ -1703,7 +1707,9 @@ export declare const v4: Elysia<"/v4", false, {
                             withOpportunity?: boolean | undefined;
                             createdAfter?: Date | null | undefined;
                         };
-                        headers: unknown;
+                        headers: {
+                            authorization: string;
+                        };
                         response: {
                             200: {
                                 [x: string]: number;
@@ -2531,6 +2537,117 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        rewards: {
+            total: {
+                distributed: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            since: Date;
+                        };
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: number;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        rewards: {
+            total: {
+                distributed: {
+                    "by-opportunities": {
+                        get: {
+                            body: unknown;
+                            params: {};
+                            query: {
+                                since: Date;
+                            };
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        rewards: {
+            total: {
+                distributed: {
+                    "by-chains": {
+                        get: {
+                            body: unknown;
+                            params: {};
+                            query: {
+                                since: Date;
+                            };
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                [x: string]: any;
+                                200: any;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        rewards: {
+            total: {
+                distributed: {
+                    "by-types": {
+                        get: {
+                            body: unknown;
+                            params: {};
+                            query: {
+                                since: Date;
+                            };
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                [x: string]: any;
+                                200: any;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        rewards: {
+            total: {
+                distributed: {
+                    "by-protocols": {
+                        get: {
+                            body: unknown;
+                            params: {};
+                            query: {
+                                since: Date;
+                            };
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                [x: string]: any;
+                                200: any;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/modules/v4/token/token.service.js

@@ -70,6 +70,15 @@ export class TokenService {
     }
     static async fetchOnChain(token) {
         const onchainData = await TokenRepository.getTokenInfo(token);
+        try {
+            // biome-ignore lint/suspicious/noControlCharactersInRegex: <explanation>
+            onchainData.name = Buffer.from(onchainData.name.replace(/\u0000/g, ""), "utf-8").toString("utf-8");
+            // biome-ignore lint/suspicious/noControlCharactersInRegex: <explanation>
+            onchainData.symbol = Buffer.from(onchainData.symbol.replace(/\u0000/g, ""), "utf-8").toString("utf-8");
+        }
+        catch (e) {
+            console.error(e);
+        }
         return {
             chainId: token.chainId,
             address: token.address,