@merkl/api 0.16.19 → 0.16.20

package/dist/src/backgroundJobs/jobs/campaignsCacheUpdater.js

@@ -141,7 +141,7 @@ export const campaignCacheUpdate = async (rawChainId, queryCampaignTypes, highCa
             }
             await OpportunityService.updateMetadata(chainId);
             // ─── Refresh Cache For GET /opportunities ────
-            await CacheService.set(TTLPresets.MIN_5, OpportunityService.getMany, { items: 50, page: 0 });
+            await CacheService.set(TTLPresets.MIN_5, OpportunityService.findMany, { items: 50, page: 0 });
             log.info(`✅ ${NETWORK_LABELS[chainId]} DB records updated successfully`);
         }
         else {

package/dist/src/backgroundJobs/jobs/sync.js

@@ -4,7 +4,7 @@ import { ChainService } from "../../modules/v4/chain";
 import { log } from "../../utils/logger";
 import Elysia from "elysia";
 export const sync = new Elysia({ prefix: "/jobs" }).get("/api/sync-with-engine", async () => {
-    const chains = await ChainService.getMany({});
+    const chains = await ChainService.findMany({});
     for (const chain of chains) {
         log.info(`fetching campaigns on ${chain.name} (chainId: ${chain.id})`);
         const campaignsV3 = await CampaignService.getFromEngineDb(chain.id, 0);

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

@@ -32,7 +32,7 @@ export declare class Cache {
      * @param key cache key
      * @returns the uncompressed (if enabled), parsed and typed data from the cache for all keys
      */
-    getMany<T extends CacheKey, Key extends T | NonNullable<CacheArg[T]>>(keys: Key[]): Promise<CacheKeys[T]["returns"][]>;
+    findMany<T extends CacheKey, Key extends T | NonNullable<CacheArg[T]>>(keys: Key[]): Promise<CacheKeys[T]["returns"][]>;
     /**
      * Get many data from cache with argument
      * @param key cache key

package/dist/src/cache/index.js

@@ -98,7 +98,7 @@ export class Cache {
      * @param key cache key
      * @returns the uncompressed (if enabled), parsed and typed data from the cache for all keys
      */
-    async getMany(keys) {
+    async findMany(keys) {
         const nonLocalKeys = keys.filter(key => !this.isLocallyCached(key)); // Keys not stored locally
         const cached = !!nonLocalKeys.length ? await this.getManyRaw(nonLocalKeys) : [];
         const res = keys.map(key => {
@@ -122,7 +122,7 @@ export class Cache {
      */
     async getManyWithArgs(key, args) {
         const actualKeys = args.map(arg => `${key}_${arg}`);
-        return this.getMany(actualKeys);
+        return this.findMany(actualKeys);
     }
     /**
      * Get data from cache or set it using the callback

package/dist/src/entities/campaign.js

@@ -7,7 +7,7 @@ export const removeTestTokens = (v) => !["aglamerkl", "test"].includes(v.campaig
 export async function getCampaignsFor(chainIds, filters = { onlyLive: false }) {
     const cachePrefix = filters?.onlyLive ? "LiveCampaigns" : "Campaigns";
     const cacheKeys = chainIds.map(chain => `${cachePrefix}_${chain}`);
-    return (await Redis.getMany(cacheKeys)).reduce((prev, allData, index) => {
+    return (await Redis.findMany(cacheKeys)).reduce((prev, allData, index) => {
         if (!!allData) {
             const chain = chainIds[index];
             prev[chain] = Object.keys(allData).reduce((acc, curr) => {

package/dist/src/libs/deprecated-merklv3/index.js

@@ -9,7 +9,7 @@ const fetchCachedData = async (chainIds, onlyLive) => {
         onlyLive = false;
     }
     const cacheKeys = chainIds.map(chainId => onlyLive ? `LiveCampaignsOldFormat_${chainId}` : `CampaignsOldFormat_${chainId}`);
-    return await Redis.getMany(cacheKeys);
+    return await Redis.findMany(cacheKeys);
 };
 export async function getClamsInfo(chainIds, AMMs, user, onlyLive) {
     if (!chainIds && !user && !AMMs) {
@@ -34,7 +34,7 @@ export async function getClamsInfo(chainIds, AMMs, user, onlyLive) {
     const cachedData = await fetchCachedData(chainIds, onlyLive);
     let chainData = [];
     if (!!user) {
-        chainData = await Redis.getMany(chainIds.map(chainId => `MerklChainData_${chainId}`));
+        chainData = await Redis.findMany(chainIds.map(chainId => `MerklChainData_${chainId}`));
     }
     /** Parallel computation of data for each chain */
     const result = {};

package/dist/src/modules/v4/accounting/accounting.controller.js

@@ -3,7 +3,7 @@ import { AccountingService, ChainDto, DateDto, GetTransactionsQueryModel, Revenu
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../../utils/throw";
 import Elysia from "elysia";
 export const AccountingController = new Elysia({ prefix: "/accounting", detail: { tags: ["Accounting"], hide: true } })
-    .get("/", async ({ query }) => await AccountingService.getMany(query), {
+    .get("/", async ({ query }) => await AccountingService.findMany(query), {
     query: GetTransactionsQueryModel,
     headers: AuthorizationHeadersDto,
     beforeHandle: async ({ headers }) => {

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

@@ -3,7 +3,7 @@ import { ChainId } from "@sdk";
 export declare class AccountingService {
     static hashId(chainId: ChainId, fromTokenId: string, toTokenId: string, timestamp: number): string;
     static getTokenId(chainId: number, address: string): string;
-    static getMany(query: GetTransactionsQueryModel): Promise<{
+    static findMany(query: GetTransactionsQueryModel): Promise<{
         id: string;
         timestamp: number;
         chainId: number;

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

@@ -8,7 +8,7 @@ export class AccountingService {
     static getTokenId(chainId, address) {
         return TokenService.hashId({ chainId, address });
     }
-    static async getMany(query) {
+    static async findMany(query) {
         return await AccountingRepository.findMany(query);
     }
     static async getRevenue() {

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

@@ -237,7 +237,7 @@ export class CampaignRepository {
                                 status: {
                                     not: RunStatus.PROCESSING,
                                 },
-                                computedUntil: { lt: currentTime }, // more than 10 min ago
+                                computedUntil: { lt: currentTime - 10 * 60 }, // more than 10 min ago
                             },
                             {
                                 status: RunStatus.PROCESSING,

package/dist/src/modules/v4/chain/chain.controller.js

@@ -17,7 +17,7 @@ export const ChainController = new Elysia({ prefix: "/chains", detail: { tags: [
 })
     // ─── Get All Supported Chains ────────────────────────────────────────
     .get("/", async ({ query }) => {
-    const chains = await ChainService.getMany(query);
+    const chains = await ChainService.findMany(query);
     return chains.map(({ Explorer, ...chain }) => ({ explorers: Explorer, ...chain }));
 }, {
     query: GetChainQueryDto,

package/dist/src/modules/v4/chain/chain.repository.d.ts

@@ -22,7 +22,7 @@ export declare abstract class ChainRepository {
      * @param query object with fields to search for
      * @returns
      */
-    static readMany(query: ChainSearchDto): Promise<({
+    static findMany(query: ChainSearchDto): Promise<({
         Explorer: {
             type: import("../../../../database/api/.generated").$Enums.ExplorerType;
             url: string;
@@ -53,11 +53,6 @@ export declare abstract class ChainRepository {
             chainId: number;
         }[];
     }>;
-    static findMany(): Promise<{
-        name: string;
-        id: number;
-        icon: string;
-    }[]>;
     static findUniqueOrThrow(id: number): Promise<{
         Explorer: {
             type: import("../../../../database/api/.generated").$Enums.ExplorerType;

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

@@ -13,14 +13,14 @@ export class ChainRepository {
     }
     static #transformQueryToPrismaFilters(query) {
         return {
-            where: { name: { contains: query.name, mode: "insensitive" } },
+            where: { name: query.name ? { contains: query.name, mode: "insensitive" } : undefined },
         };
     }
     /** Returns many chains based on query
      * @param query object with fields to search for
      * @returns
      */
-    static async readMany(query) {
+    static async findMany(query) {
         const args = ChainRepository.#transformQueryToPrismaFilters(query);
         return apiDbClient.chain.findMany({
             include: { Explorer: { take: 5 } },
@@ -56,9 +56,6 @@ export class ChainRepository {
         await ExplorerRepository.create(data.id, data.explorerType, data.explorerUrl);
         return await ChainRepository.findUniqueOrThrow(data.id);
     }
-    static async findMany() {
-        return apiDbClient.chain.findMany();
-    }
     static async findUniqueOrThrow(id) {
         return apiDbClient.chain.findUniqueOrThrow({
             where: {

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

@@ -12,12 +12,7 @@ export declare abstract class ChainService {
         id: number;
         icon: string;
     }) | null>;
-    static findMany(): Promise<{
-        name: string;
-        id: number;
-        icon: string;
-    }[]>;
-    static getMany(query: ChainSearchDto): Promise<({
+    static findMany(query: ChainSearchDto): Promise<({
         Explorer: {
             type: import("../../../../database/api/.generated").$Enums.ExplorerType;
             url: string;

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

@@ -7,11 +7,8 @@ export class ChainService {
         return ChainRepository.read(chainId);
     }
     //TODO: determine find vs get nomenclature and cache handling
-    static async findMany() {
-        return await CacheService.wrap(TTLPresets.HOUR_4, ChainRepository.findMany);
-    }
-    static async getMany(query) {
-        return ChainRepository.readMany(query);
+    static async findMany(query) {
+        return await CacheService.wrap(TTLPresets.HOUR_4, ChainRepository.findMany, query);
     }
     static async countMany(query) {
         return ChainRepository.countMany(query);

package/dist/src/modules/v4/opportunity/opportunity.controller.js

@@ -45,7 +45,7 @@ export const OpportunityController = new Elysia({
     detail: { hide: true },
 })
     // ─── Get All Opportunities ───────────────────────────────────────────
-    .get("/", async ({ query }) => await OpportunityService.getMany(query), {
+    .get("/", async ({ query }) => await OpportunityService.findMany(query), {
     query: GetOpportunitiesQueryDto,
     detail: {
         description: `**Retrieve Multiple Opportunities**

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

@@ -266,7 +266,7 @@ export declare abstract class OpportunityService {
      * @param query
      * @returns A list of opportunities
      */
-    static getMany(query: GetOpportunitiesQueryModel): Promise<{
+    static findMany(query: GetOpportunitiesQueryModel): Promise<{
         apr: number;
         aprRecord: {
             cumulated: number;

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

@@ -271,7 +271,7 @@ export class OpportunityService {
      * @param query
      * @returns A list of opportunities
      */
-    static async getMany(query) {
+    static async findMany(query) {
         return await CacheService.wrap(TTLPresets.MIN_5, async (query) => {
             const opportunities = await OpportunityRepository.findMany(query);
             return opportunities.map(OpportunityService.formatResponse);

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

@@ -44,7 +44,7 @@ export class ProtocolService {
                 log.info(`Updated protocol ${protocol.id} icon`);
             }
         }
-        const chains = await ChainService.findMany();
+        const chains = await ChainService.findMany({});
         for (const chain of chains) {
             if (chain.icon.includes(oldUrl)) {
                 await ChainService.update(chain.id, { icon: chain.icon.replace(oldUrl, newUrl) });

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

@@ -174,7 +174,7 @@ export class RewardService {
         return rewards;
     }
     static async getUserRewardsByChain(user, withToken, chainFilter = [], connectedChainId = null, withTestTokens = false) {
-        const chains = await ChainService.findMany();
+        const chains = await ChainService.findMany({});
         let chainIds = !chainFilter || !chainFilter.length
             ? chains.map(({ id }) => id)
             : chains.map(({ id }) => id).filter(id => chainFilter.includes(id));

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

@@ -54,7 +54,7 @@ export class UserService {
     static async syncOpportunityTags() {
         const users = await UserRepository.findManyWithTags();
         for (const user of users) {
-            const opportunities = await OpportunityService.getMany({ creatorAddress: user.address });
+            const opportunities = await OpportunityService.findMany({ creatorAddress: user.address });
             for (const opportunity of opportunities) {
                 if (!user.tags.every(tag => opportunity.tags.includes(tag))) {
                     log.local(`updating tags for opportunity ${opportunity.id}: adding ${user.tags.join(",")}`);

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

@@ -33,7 +33,7 @@ export default (app) => app.use(checkQueryAddressValidity()).get("/multiChainPos
     for (const chainId of chainIds)
         throwOnUnsupportedChainId(chainId);
     const cacheKeys = chainIds.map(chainId => `LiveCampaigns_${chainId}`);
-    const cacheData = await Redis.getMany(cacheKeys);
+    const cacheData = await Redis.findMany(cacheKeys);
     const promises = [];
     let i = 0;
     for (const chainId of chainIds) {

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

@@ -1,4 +1,5 @@
 import { Redis } from "../../cache";
+import { OpportunityService } from "../../modules/v4/opportunity";
 import { t } from "elysia";
 import { fillCampaigns } from "../../entities/opportunity";
 import param from "../../types/parameters";
@@ -25,6 +26,10 @@ export const response = t.Record(t.TemplateLiteral([param.Type.type, t.Literal("
 }));
 export default (app) => {
     return app.get("/opportunity", async ({ query: { campaigns: showCampaigns, ...filters } }) => {
+        if (process.env.FF_OPPORTUNITY === "true") {
+            const opportunities = await OpportunityService.findMany({ items: 10_000 });
+            return {};
+        }
         const opportunities = await Redis.get(filters?.testTokens ? "OpportunitiesWithTest" : "Opportunities");
         const returnedOpportunities = {};
         const corresponds = (opp) => {