@merkl/api 0.19.49 → 0.20.0

package/dist/src/eden/index.d.ts

@@ -1893,11 +1893,15 @@ declare const eden: {
                         data: {
                             properties: {
                                 "Icon (Required)": {
-                                    files: {
+                                    files: ({
                                         file: {
                                             url: string;
                                         };
-                                    }[];
+                                    } | {
+                                        external: {
+                                            url: string;
+                                        };
+                                    })[];
                                 };
                                 "Address (in checksum format) (Required)": {
                                     rich_text: {
@@ -5631,11 +5635,15 @@ declare const eden: {
                         data: {
                             properties: {
                                 "Icon (Required)": {
-                                    files: {
+                                    files: ({
                                         file: {
                                             url: string;
                                         };
-                                    }[];
+                                    } | {
+                                        external: {
+                                            url: string;
+                                        };
+                                    })[];
                                 };
                                 "Address (in checksum format) (Required)": {
                                     rich_text: {
@@ -10435,11 +10443,15 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             data: {
                                 properties: {
                                     "Icon (Required)": {
-                                        files: {
+                                        files: ({
                                             file: {
                                                 url: string;
                                             };
-                                        }[];
+                                        } | {
+                                            external: {
+                                                url: string;
+                                            };
+                                        })[];
                                     };
                                     "Address (in checksum format) (Required)": {
                                         rich_text: {
@@ -15559,11 +15571,15 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         data: {
                             properties: {
                                 "Icon (Required)": {
-                                    files: {
+                                    files: ({
                                         file: {
                                             url: string;
                                         };
-                                    }[];
+                                    } | {
+                                        external: {
+                                            url: string;
+                                        };
+                                    })[];
                                 };
                                 "Address (in checksum format) (Required)": {
                                     rich_text: {
@@ -19297,11 +19313,15 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         data: {
                             properties: {
                                 "Icon (Required)": {
-                                    files: {
+                                    files: ({
                                         file: {
                                             url: string;
                                         };
-                                    }[];
+                                    } | {
+                                        external: {
+                                            url: string;
+                                        };
+                                    })[];
                                 };
                                 "Address (in checksum format) (Required)": {
                                     rich_text: {

package/dist/src/index.d.ts

@@ -2296,11 +2296,15 @@ declare const app: Elysia<"", false, {
                             data: {
                                 properties: {
                                     "Icon (Required)": {
-                                        files: {
+                                        files: ({
                                             file: {
                                                 url: string;
                                             };
-                                        }[];
+                                        } | {
+                                            external: {
+                                                url: string;
+                                            };
+                                        })[];
                                     };
                                     "Address (in checksum format) (Required)": {
                                         rich_text: {

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

@@ -152,4 +152,4 @@ export const main = async () => {
     // if (failedBatches.length === 0) await file.delete();
     process.exit(0);
 };
-main();
+await main();

package/dist/src/jobs/update-rpc-calls-cache.d.ts

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

package/dist/src/jobs/update-rpc-calls-cache.js

@@ -0,0 +1,20 @@
+import { CacheService } from "@/modules/v4/cache";
+import { TTLPresets } from "@/modules/v4/cache/cache.model";
+import { ChainService } from "@/modules/v4/chain/chain.service";
+import { MerklRootRepository } from "@/modules/v4/merklRoot/merklRoot.repository";
+import { NETWORK_LABELS, log } from "@sdk";
+const main = async () => {
+    try {
+        const chains = await ChainService.getSupportedIds();
+        const promises = [];
+        for (const chain of chains)
+            promises.push(CacheService.set(TTLPresets.MIN_10, MerklRootRepository.fetch, chain).catch(_err => log.warn(`RPC calls cache update failed for ${NETWORK_LABELS[chain]}.`)));
+        await Promise.allSettled(promises);
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+};
+await main();

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

@@ -19,6 +19,13 @@ export declare class MerklRootService {
      * @returns object with live and last tree roots
      */
     static fetch(chainId: ChainId): Promise<any>;
+    static fetchFromCache(chainId: ChainId): Promise<{
+        live: any;
+        tree: any;
+        lastTree: any;
+        endOfDisputePeriod: any;
+        disputer: any;
+    }>;
     /**
      * Fetch all roots for the provided chains
      * @param chainIds to fetch roots for

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

@@ -1,3 +1,4 @@
+import { HttpError } from "@/errors";
 import { log } from "@/utils/logger";
 import { NETWORK_LABELS, withTimeout } from "@sdk";
 import { CacheService } from "../cache";
@@ -29,6 +30,19 @@ export class MerklRootService {
             throw e;
         }
     }
+    static async fetchFromCache(chainId) {
+        try {
+            const data = await CacheService.get(MerklRootRepository.fetch, [chainId]);
+            if (data === null)
+                throw new Error("DATA_NOT_FOUND");
+            return data;
+        }
+        catch (err) {
+            if (err && err instanceof Error && err.message === "DATA_NOT_FOUND")
+                throw new HttpError(`Failed to fetch data for chain ${chainId}.`, 500);
+            return await MerklRootRepository.fetch(chainId);
+        }
+    }
     /**
      * Fetch all roots for the provided chains
      * @param chainIds to fetch roots for
@@ -38,7 +52,7 @@ export class MerklRootService {
         return await CacheService.wrap(TTLPresets.MIN_1, async () => {
             let ids = chainIds ?? (await ChainService.getIds());
             /** Fetch current Merkle Roots */
-            const merkleRootsPromises = await Promise.allSettled(ids.map(chainId => MerklRootService.fetch(chainId)));
+            const merkleRootsPromises = await Promise.allSettled(ids.map(chainId => MerklRootService.fetchFromCache(chainId)));
             /** Filter out unsuccessful chainIds */
             ids = ids.filter((_, index) => merkleRootsPromises[index].status === "fulfilled");
             const roots = merkleRootsPromises

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

@@ -237,7 +237,7 @@ export class RewardService {
         if (isBlacklisted)
             return res;
         /** Fetch current Merkle Roots */
-        const merkleRootsPromises = await Promise.allSettled(chainIds.map(chainId => MerklRootService.fetch(chainId)));
+        const merkleRootsPromises = await Promise.allSettled(chainIds.map(chainId => MerklRootService.fetchFromCache(chainId)));
         /** Filter out unsuccessful chainIds */
         chainIds = chainIds.filter((_, index) => merkleRootsPromises[index].status === "fulfilled");
         const merkleRoots = merkleRootsPromises
@@ -288,7 +288,7 @@ export class RewardService {
         }
     }
     static async countOnChain(chainId) {
-        const roots = await MerklRootService.fetch(chainId);
+        const roots = await MerklRootService.fetchFromCache(chainId);
         const promises = [
             RewardRepository.countRewardAndBreakdownOnChain(chainId, roots.tree),
             RewardRepository.countRewardAndBreakdownOnChain(chainId, roots.lastTree),
@@ -300,42 +300,42 @@ export class RewardService {
         };
     }
     static async breakdownForCampaign(query) {
-        const root = await MerklRootService.fetch(query.chainId);
+        const root = await MerklRootService.fetchFromCache(query.chainId);
         const id = CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId });
         return RewardRepository.breakdownForCampaign(root.live, id, query);
     }
     static async countForCampaign(query) {
-        const root = await MerklRootService.fetch(query.chainId);
+        const root = await MerklRootService.fetchFromCache(query.chainId);
         const id = CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId });
         return RewardRepository.countForCampaign(id, root.live);
     }
     static async totalForCampaign(query) {
-        const root = await MerklRootService.fetch(query.chainId);
+        const root = await MerklRootService.fetchFromCache(query.chainId);
         return RewardRepository.totalForCampaign(CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId }), root.live);
     }
     static async breakdownForToken(query) {
         return CacheService.wrap(TTLPresets.MIN_10, async (query) => {
-            const root = await MerklRootService.fetch(query.chainId);
+            const root = await MerklRootService.fetchFromCache(query.chainId);
             const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
             return RewardRepository.breakdownForToken(root.live, id, query);
         }, query);
     }
     static async countForToken(query) {
         return CacheService.wrap(TTLPresets.MIN_10, async (query) => {
-            const root = await MerklRootService.fetch(query.chainId);
+            const root = await MerklRootService.fetchFromCache(query.chainId);
             const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
             return RewardRepository.countForToken(id, root.live);
         }, query);
     }
     static async totalForToken(query) {
         return CacheService.wrap(TTLPresets.MIN_10, async (query) => {
-            const root = await MerklRootService.fetch(query.chainId);
+            const root = await MerklRootService.fetchFromCache(query.chainId);
             const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
             return RewardRepository.totalForToken(id, root.live);
         }, query);
     }
     static async getAmountAndClaimedForCampaigns(x) {
-        const currentRoot = await MerklRootService.fetch(x.chainId);
+        const currentRoot = await MerklRootService.fetchFromCache(x.chainId);
         return await RewardRepository.getAmountAndClaimedForCampaigns(currentRoot.live, x);
     }
     static async getUnclaimed(x) {

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

@@ -2166,11 +2166,15 @@ export declare const v4: Elysia<"/v4", false, {
                             data: {
                                 properties: {
                                     "Icon (Required)": {
-                                        files: {
+                                        files: ({
                                             file: {
                                                 url: string;
                                             };
-                                        }[];
+                                        } | {
+                                            external: {
+                                                url: string;
+                                            };
+                                        })[];
                                     };
                                     "Address (in checksum format) (Required)": {
                                         rich_text: {

package/dist/src/modules/v4/token/token.controller.d.ts

@@ -293,11 +293,15 @@ export declare const TokenController: Elysia<"/tokens", false, {
                         data: {
                             properties: {
                                 "Icon (Required)": {
-                                    files: {
+                                    files: ({
                                         file: {
                                             url: string;
                                         };
-                                    }[];
+                                    } | {
+                                        external: {
+                                            url: string;
+                                        };
+                                    })[];
                                 };
                                 "Address (in checksum format) (Required)": {
                                     rich_text: {

package/dist/src/modules/v4/token/token.model.d.ts

@@ -76,11 +76,15 @@ export declare const NotionWebhookDto: import("@sinclair/typebox").TObject<{
     data: import("@sinclair/typebox").TObject<{
         properties: import("@sinclair/typebox").TObject<{
             "Icon (Required)": import("@sinclair/typebox").TObject<{
-                files: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                files: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
                     file: import("@sinclair/typebox").TObject<{
                         url: import("@sinclair/typebox").TString;
                     }>;
-                }>>;
+                }>, import("@sinclair/typebox").TObject<{
+                    external: import("@sinclair/typebox").TObject<{
+                        url: import("@sinclair/typebox").TString;
+                    }>;
+                }>]>>;
             }>;
             "Address (in checksum format) (Required)": import("@sinclair/typebox").TObject<{
                 rich_text: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{

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

@@ -63,7 +63,12 @@ export const CreateTokenDto = t.Object({
 export const NotionWebhookDto = t.Object({
     data: t.Object({
         properties: t.Object({
-            "Icon (Required)": t.Object({ files: t.Array(t.Object({ file: t.Object({ url: t.String() }) })) }),
+            "Icon (Required)": t.Object({
+                files: t.Array(t.Union([
+                    t.Object({ file: t.Object({ url: t.String() }) }),
+                    t.Object({ external: t.Object({ url: t.String() }) }),
+                ])),
+            }),
             "Address (in checksum format) (Required)": t.Object({
                 rich_text: t.Array(t.Object({ plain_text: t.String() })),
             }),

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

@@ -290,7 +290,8 @@ export class TokenService {
         const env = process.env.ENV === "prod" ? "production" : process.env.ENV;
         const bucket = new BucketService(`merkl-${env}-tokens`, `angle-${env}-1`);
         const properties = body.data.properties;
-        const icon = properties["Icon (Required)"].files?.[0]?.file.url;
+        const file = properties["Icon (Required)"].files[0];
+        const icon = "external" in file ? file.external.url : file.file.url;
         const iconFile = await fetch(icon);
         const mimeType = iconFile.headers.get("content-type");
         const extension = mimeType.split("/")[1].split("+")[0];