@merkl/api 0.20.16 → 0.20.18

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

@@ -7756,23 +7756,47 @@ declare const eden: {
                 200: any;
             }>>;
         };
-        euler: {
-            get: (options: {
+        euler: ((params: {
+            chainId: string | number;
+        }) => {
+            get: (options?: {
                 headers?: Record<string, unknown> | undefined;
-                query: {};
+                query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
-            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: EulerVaultType[];
             }>>;
-        };
-        "euler-update-collat": {
-            get: (options: {
+        }) & {
+            get: (options?: {
                 headers?: Record<string, unknown> | undefined;
-                query: {};
+                query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
-            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: void;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: EulerVaultType[];
             }>>;
+            update: ((params: {
+                chainId: string | number;
+            }) => {
+                post: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            }) & {
+                post: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
         };
         fetch: {
             get: (options: {
@@ -13188,7 +13212,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
             get: {
                 body: unknown;
                 params: {};
-                query: {};
+                query: unknown;
                 headers: unknown;
                 response: {
                     200: EulerVaultType[];
@@ -13196,14 +13220,54 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
             };
         };
     } & {
-        "euler-update-collat": {
-            get: {
-                body: unknown;
-                params: {};
-                query: {};
-                headers: unknown;
-                response: {
-                    200: void;
+        euler: {
+            ":chainId": {
+                get: {
+                    body: unknown;
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: EulerVaultType[];
+                    };
+                };
+            };
+        };
+    } & {
+        euler: {
+            update: {
+                post: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        euler: {
+            update: {
+                ":chainId": {
+                    post: {
+                        body: unknown;
+                        params: {
+                            chainId: number;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
                 };
             };
         };
@@ -21462,23 +21526,47 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 200: any;
             }>>;
         };
-        euler: {
-            get: (options: {
+        euler: ((params: {
+            chainId: string | number;
+        }) => {
+            get: (options?: {
                 headers?: Record<string, unknown> | undefined;
-                query: {};
+                query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
-            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: EulerVaultType[];
             }>>;
-        };
-        "euler-update-collat": {
-            get: (options: {
+        }) & {
+            get: (options?: {
                 headers?: Record<string, unknown> | undefined;
-                query: {};
+                query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
-            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: void;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: EulerVaultType[];
             }>>;
+            update: ((params: {
+                chainId: string | number;
+            }) => {
+                post: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            }) & {
+                post: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
         };
         fetch: {
             get: (options: {

package/dist/src/engine/dynamicData/implementations/EventBased.js

@@ -39,8 +39,9 @@ async function computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaign
     // Bucket service
     let tvl = 0;
     try {
-        console.log("BUCKET NAME:", bucketName);
-        const bucket = new BucketService(bucketName, "merkl-production");
+        if (bucketName === undefined)
+            console.log("EVENT_BASED:", states);
+        const bucket = new BucketService("merkl-production-states", "merkl-production");
         const storedStates = JSON.parse(await bucket.pull(fileName));
         for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
             tvl += BN2Number(value.allTimeValue, 18 - decimalsCurrency);

package/dist/src/engine/dynamicData/implementations/UniswapV4.js

@@ -43,8 +43,9 @@ async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID, price
     let amount0 = 0;
     let amount1 = 0;
     try {
-        console.log("BUCKET NAME:", bucketName);
-        const bucket = new BucketService(bucketName, "merkl-production");
+        if (bucketName === undefined)
+            console.log("UNIV4", states);
+        const bucket = new BucketService("merkl-production-states", "merkl-production");
         const storedStates = JSON.parse(await bucket.pull(fileName));
         for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
             amount0 += BN2Number(value.amount0, decimalsCurrency0);

package/dist/src/engine/dynamicData/utils/getEulerV2Vaults.d.ts

@@ -1,7 +1,9 @@
-import { type EulerVaultType } from "@sdk";
+import { type EulerVaultType, eulerChainIds } from "@sdk";
 export declare enum LoggedEntityType {
     EULER = "EULER_VAULT",
     UNISWAP_V4 = "UNISWAP_V4"
 }
-export declare function getEulerV2Vaults(): Promise<EulerVaultType[]>;
-export declare function updateEulerVaultsCollatInDatabase(): Promise<void>;
+type EulerChainId = (typeof eulerChainIds)[number];
+export declare function getEulerV2Vaults(chainId?: EulerChainId): Promise<EulerVaultType[]>;
+export declare function updateEulerVaultsCollatInDatabase(chainId?: EulerChainId): Promise<void>;
+export {};

package/dist/src/engine/dynamicData/utils/getEulerV2Vaults.js

@@ -34,7 +34,6 @@ async function computeCollatListAndReturnVaults(chainId, vaults) {
     for (const [index, vault] of vaults.entries()) {
         const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
         for (const collat of collatArray) {
-            // FIXME
             if (!!vault.collaterals &&
                 vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase())) {
                 continue;
@@ -119,13 +118,20 @@ async function computeCollatListAndReturnVaults(chainId, vaults) {
     }))));
     return vaultsPerChain;
 }
-export async function getEulerV2Vaults() {
+export async function getEulerV2Vaults(chainId) {
+    let chainIdArray;
+    if (!!chainId) {
+        chainIdArray = [chainId];
+    }
+    else {
+        chainIdArray = eulerChainIds;
+    }
     let vaults = [];
     // 0_ Fetch all euler vaults from database
     const storedVaults = await apiDbClient.logged.findMany({
         where: { type: LoggedEntityType.EULER },
     });
-    const res = await Promise.all(eulerChainIds.map(async (chainId) => {
+    const res = await Promise.all(chainIdArray.map(async (chainId) => {
         let vaultsPerChain = [];
         chainId = chainId;
         try {
@@ -205,7 +211,15 @@ export async function getEulerV2Vaults() {
     log.info("👋 exiting getEulerV2Vaults");
     return vaults;
 }
-export async function updateEulerVaultsCollatInDatabase() {
+export async function updateEulerVaultsCollatInDatabase(chainId) {
+    log.info("🏁 start updating vaults collat data");
+    let chainIdArray;
+    if (!!chainId) {
+        chainIdArray = [chainId];
+    }
+    else {
+        chainIdArray = eulerChainIds;
+    }
     // 0_ Fetch all euler vaults from database
     const vaults = await apiDbClient.logged.findMany({
         where: { type: LoggedEntityType.EULER },
@@ -213,7 +227,7 @@ export async function updateEulerVaultsCollatInDatabase() {
     const clonedVaults = _.cloneDeep(vaults);
     let toUpdateVaults = [];
     // 1_ Return all vaults already stored with their collateral updated
-    const res = await Promise.all(eulerChainIds.map(async (chainId) => computeCollatListAndReturnVaults(chainId, clonedVaults.filter(entity => entity.chainId === chainId).map(entity => entity.entityData))));
+    const res = await Promise.all(chainIdArray.map(async (chainId) => computeCollatListAndReturnVaults(chainId, clonedVaults.filter(entity => entity.chainId === chainId).map(entity => entity.entityData))));
     for (const resPerChain of res) {
         if (!!resPerChain && resPerChain.length > 0) {
             toUpdateVaults = toUpdateVaults.concat(resPerChain.filter(updatedVault => {
@@ -243,4 +257,9 @@ export async function updateEulerVaultsCollatInDatabase() {
             throw new Error("Error while updating vaults to API database (`Logged` table)");
         }
     }
+    else {
+        log.info("🤷🏻 no vaults to update");
+    }
+    log.info("🏁 exiting vault collateral update");
+    return;
 }

package/dist/src/engine/opportunityMetadata/implementations/Morpho.js

@@ -33,7 +33,8 @@ export class MorphoMetadata {
                 }
                 case MorphoSubCampaignType.BORROWING_BLUE:
                 case MorphoSubCampaignType.COLLATERAL_BLUE: {
-                    return `https://www.compound.blue/borrow/${params.targetToken.toLowerCase()}`;
+                    const typedParams = params;
+                    return `https://www.compound.blue/borrow/${typedParams.marketId.toLowerCase()}`;
                 }
             }
         }

package/dist/src/index.d.ts

@@ -5023,7 +5023,7 @@ declare const app: Elysia<"", false, {
             get: {
                 body: unknown;
                 params: {};
-                query: {};
+                query: unknown;
                 headers: unknown;
                 response: {
                     200: EulerVaultType[];
@@ -5031,14 +5031,54 @@ declare const app: Elysia<"", false, {
             };
         };
     } & {
-        "euler-update-collat": {
-            get: {
-                body: unknown;
-                params: {};
-                query: {};
-                headers: unknown;
-                response: {
-                    200: void;
+        euler: {
+            ":chainId": {
+                get: {
+                    body: unknown;
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: EulerVaultType[];
+                    };
+                };
+            };
+        };
+    } & {
+        euler: {
+            update: {
+                post: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        euler: {
+            update: {
+                ":chainId": {
+                    post: {
+                        body: unknown;
+                        params: {
+                            chainId: number;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
                 };
             };
         };

package/dist/src/jobs/pendings.js

@@ -177,9 +177,7 @@ const updatePendings = async (data) => {
         await apiDbClient.rewardBreakdown.createMany({
             data: breakdownToCreate.map(x => {
                 const rewardId = RewardService.hashId(data.root, x.recipient, rewardTokenId);
-                const rewardBreakdownId = RewardService.hashBreakdownId(rewardId, campaignId, x.reason);
                 return {
-                    stringId: rewardBreakdownId,
                     reason: x.reason,
                     amount: "0",
                     pending: x.pending,

package/dist/src/jobs/update-euler-vaults.js

@@ -1,13 +1,13 @@
 import { Redis } from "@/cache";
 import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/engine/dynamicData/utils/getEulerV2Vaults";
 (async () => {
+    await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());
     try {
-        await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());
         await updateEulerVaultsCollatInDatabase();
-        process.exit(1);
     }
-    catch (error) {
-        console.error(error);
+    catch (e) {
+        console.error(e);
         process.exit(1);
     }
+    process.exit(0);
 })();

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

@@ -58,25 +58,22 @@ const etherlinkReferralProgram = {
     cumulativeBoost: false,
 };
 const blacklistEtherlink = [
-    "0x8872642881C7C3f4124f3215a0D12CDf807EEB01",
-    "0x50D760f3a8630e620BC0D29E8031E8a37dEB4751",
-    "0xA237E96Abc3180AF377EcF22aE590C02991f9b1F",
     "0x851CAD3E0b90C2535725eCeFcCDfeeb7996B9414",
-    "0x931ef6d9ea6FfFfd73D5F7CE35664BAD76cBc784",
-    "0xf663c334Ae22e9A086193A52918f873154Bdf2d4",
-    "0x6c1b204185A55E9DaA0bF026720Fe94458ddd89F",
-    "0x56A8b583276278513Eb78c3d132a80c1e81B9405",
-    "0x6a2f09Bc9E6b82b38FCa096792B94f36FAd657Ac",
     "0xf99Fdd1e71838433516DE7aD98aa82BFa3f17AE2",
-    "0xf1fAD4fecd686a79Fd2a4618F657f0BA0332e18A",
-    "0x51832D40579d86fb95Cc843EF32326BD51904956",
     "0x0D1C515CCb1B723eCBA2Cbb14c458168078529DA",
+    "0x8872642881C7C3f4124f3215a0D12CDf807EEB01",
     "0x4d6ab6cBd964Fa1D33dA0232DA21fA3E5d23d05D",
+    "0x931ef6d9ea6FfFfd73D5F7CE35664BAD76cBc784",
     "0x6ECEc7954b61Da887B8f3e56111D7Dd6bebc3877",
+    "0x6a2f09Bc9E6b82b38FCa096792B94f36FAd657Ac",
     "0x41Be85bf6c460b1DC35efBE2C3143F9732CD6496",
+    "0x56A8b583276278513Eb78c3d132a80c1e81B9405",
     "0x635518E05BAe895F85680Ce66Fb8EA92EE64FE2f",
+    "0xf1fAD4fecd686a79Fd2a4618F657f0BA0332e18A",
     "0xB05D1019772a14bb8853A94469B45ECfC7A985E8",
+    "0xf663c334Ae22e9A086193A52918f873154Bdf2d4",
     "0x82DAa20C1781d142295a7cF2a8913798695E50a2",
+    "0x51832D40579d86fb95Cc843EF32326BD51904956",
     "0xbC086a895F6c1fF7Dd09022cC7fDEd52a2451Be5",
     "0xFdAD5D95246E8b5B5147bCDE23ddCc6BbF1f7fC0",
     "0x19f898d95295D072235272C015B80787B177140e",
@@ -95,11 +92,13 @@ const blacklistEtherlink = [
     "0x0893cA2b0f0b8B87815B61c7717C25B8Bf834082",
     "0x9D0E0e95305872E0f8065093b66E5FA224B5826f",
     "0xa0E147eA78D8d696D73bbd43dE353b3ab076B3a0",
-    "0x196A8F57ff3AfB509f0014EDBa108A0BFeF0a84a",
+    "0xA237E96Abc3180AF377EcF22aE590C02991f9b1F",
+    "0x50D760f3a8630e620BC0D29E8031E8a37dEB4751",
     "0x8F6dcd0db53029d1116E86DA6d38Bf047f504e08",
     "0x1CC9F701399f586568F2B0498b137c561B288F6B",
     "0xB387D0A73619791420De4a1e5e710023Cb0f49c0",
     "0xA0fc58e4EE3a3E183dfa492147C97e81D42f5C86",
+    "0xEcCcFF3Ca6580BeeB85c679495afBDB1877F3a99",
 ];
 export var swapxCampaigns;
 (function (swapxCampaigns) {

package/dist/src/routes/v3/euler.d.ts

@@ -1,4 +1,4 @@
-import { type Elysia } from "elysia";
+import type { Elysia } from "elysia";
 declare const _default: (app: Elysia) => Elysia<"", false, {
     decorator: {};
     store: {};
@@ -16,7 +16,7 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
         get: {
             body: unknown;
             params: {};
-            query: {};
+            query: unknown;
             headers: unknown;
             response: {
                 200: EulerVaultType[];
@@ -24,14 +24,54 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
         };
     };
 } & {
-    "euler-update-collat": {
-        get: {
-            body: unknown;
-            params: {};
-            query: {};
-            headers: unknown;
-            response: {
-                200: void;
+    euler: {
+        ":chainId": {
+            get: {
+                body: unknown;
+                params: {
+                    chainId: number;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: EulerVaultType[];
+                };
+            };
+        };
+    };
+} & {
+    euler: {
+        update: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: void;
+                };
+            };
+        };
+    };
+} & {
+    euler: {
+        update: {
+            ":chainId": {
+                post: {
+                    body: unknown;
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
             };
         };
     };

package/dist/src/routes/v3/euler.js

@@ -1,17 +1,42 @@
 import { Redis } from "@/cache";
 import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/engine/dynamicData/utils/getEulerV2Vaults";
-import { t } from "elysia";
+import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
+import { ChainUniqueDto } from "@/modules/v4/chain/chain.model";
+import { UnsupportedNetwork } from "@/utils/error";
+import { eulerChainIds } from "@sdk";
 export default (app) => app
     .get("/euler", async () => {
     return await Redis.getOrSet("EulerV2Vaults", getEulerV2Vaults);
 }, {
-    query: t.Object({}),
+    tags: ["euler"],
+})
+    .get("/euler/:chainId", async ({ params }) => {
+    return (await Redis.getOrSet("EulerV2Vaults", getEulerV2Vaults, params.chainId)).filter(v => v.chainId === params.chainId);
+}, {
+    params: ChainUniqueDto,
+    beforeHandle: ({ params }) => {
+        if (!eulerChainIds.includes(params.chainId))
+            throw new UnsupportedNetwork(params.chainId);
+    },
     tags: ["euler"],
 })
     // DO NOT MODIFY THIS LINE, USED FOR DEBUGGING PURPOSES
-    .get("/euler-update-collat", async () => {
+    .post("/euler/update", async () => {
     return await updateEulerVaultsCollatInDatabase();
 }, {
-    query: t.Object({}),
+    headers: AuthorizationHeadersDto,
+    beforeHandle: BackOfficeGuard,
+    tags: ["euler"],
+})
+    .post("/euler/update/:chainId", async ({ params }) => {
+    return await updateEulerVaultsCollatInDatabase(params.chainId);
+}, {
+    params: ChainUniqueDto,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: async ({ params, headers }) => {
+        if (!eulerChainIds.includes(params.chainId))
+            throw new UnsupportedNetwork(params.chainId);
+        await BackOfficeGuard({ headers });
+    },
     tags: ["euler"],
 });

package/dist/src/routes/v3/router.d.ts

@@ -231,7 +231,7 @@ export declare const v3: Elysia<"/v3", false, {
             get: {
                 body: unknown;
                 params: {};
-                query: {};
+                query: unknown;
                 headers: unknown;
                 response: {
                     200: EulerVaultType[];
@@ -239,14 +239,54 @@ export declare const v3: Elysia<"/v3", false, {
             };
         };
     } & {
-        "euler-update-collat": {
-            get: {
-                body: unknown;
-                params: {};
-                query: {};
-                headers: unknown;
-                response: {
-                    200: void;
+        euler: {
+            ":chainId": {
+                get: {
+                    body: unknown;
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: EulerVaultType[];
+                    };
+                };
+            };
+        };
+    } & {
+        euler: {
+            update: {
+                post: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        euler: {
+            update: {
+                ":chainId": {
+                    post: {
+                        body: unknown;
+                        params: {
+                            chainId: number;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
                 };
             };
         };