@merkl/api 0.10.325 → 0.10.327

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

@@ -2789,8 +2789,8 @@ declare const eden: {
                 headers?: Record<string, unknown> | undefined;
                 query: {
                     chainIds?: string | string[] | undefined;
+                    creatorTag?: string | undefined;
                     user: string;
-                    creatorTag: string;
                 };
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
@@ -6602,8 +6602,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 params: {};
                 query: {
                     chainIds?: string | string[] | undefined;
+                    creatorTag?: string | undefined;
                     user: string;
-                    creatorTag: string;
                 };
                 headers: unknown;
                 response: {
@@ -9783,8 +9783,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 headers?: Record<string, unknown> | undefined;
                 query: {
                     chainIds?: string | string[] | undefined;
+                    creatorTag?: string | undefined;
                     user: string;
-                    creatorTag: string;
                 };
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{

package/dist/src/index.d.ts

@@ -3495,8 +3495,8 @@ declare const app: Elysia<"", false, {
                 params: {};
                 query: {
                     chainIds?: string | string[] | undefined;
+                    creatorTag?: string | undefined;
                     user: string;
-                    creatorTag: string;
                 };
                 headers: unknown;
                 response: {

package/dist/src/libs/campaigns/campaignTypes/ERC20DynamicData.js

@@ -1,6 +1,5 @@
 import { merklChainDataWithCache } from "../../merklChainData";
-import { BN2Number, BalancerPoolInterface, ERC20Interface, EnzymeInterface, FactoryInterface, MetamorphoInterface, YEAR, } from "@sdk";
-import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { BN2Number, BalancerPoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, MetamorphoInterface, YEAR, } from "@sdk";
 import { Pricer } from "../../../utils/pricer";
 import { getLastEligibilityRatio } from "../utils/getLastEligibilityRatio";
 import { getTVL } from "./ERC20SubTypes/helpers/getTVL";
@@ -57,9 +56,7 @@ export async function ERC20DynamicData(chainId, campaigns) {
             target: campaign.campaignParameters.targetToken,
         });
     }
-    const resultRound1 = await batchMulticallCallWithRetry(chainId, {
-        calls: callsRounds1,
-    });
+    const resultRound1 = await ChainInteractionService(chainId).fetchState(callsRounds1);
     const tokenTypesByCampaign = {};
     // Round 2: Decode result from round 1 and get some additional info for the types before the final calls
     const callsRounds2 = [];
@@ -75,9 +72,7 @@ export async function ERC20DynamicData(chainId, campaigns) {
         tokenTypesByCampaign[campaign.campaignId] = typeStruct;
         callsRounds2.push(...typeStruct.calls);
     }
-    const resultRound2 = await batchMulticallCallWithRetry(chainId, {
-        calls: callsRounds2,
-    });
+    const resultRound2 = await ChainInteractionService(chainId).fetchState(callsRounds2);
     // Round 3: Decode result from round 2 and get some additional info for the types before the final calls
     const callsRounds3 = [];
     let j = 0;
@@ -88,9 +83,7 @@ export async function ERC20DynamicData(chainId, campaigns) {
         j += callsForCampaign;
         callsRounds3.push(...tokenTypesByCampaign[campaign.campaignId].calls);
     }
-    const resultRound3 = await batchMulticallCallWithRetry(chainId, {
-        calls: callsRounds3,
-    });
+    const resultRound3 = await ChainInteractionService(chainId).fetchState(callsRounds3);
     // Final round before execute
     let callsFinal = [];
     j = 0;
@@ -101,9 +94,7 @@ export async function ERC20DynamicData(chainId, campaigns) {
         callsFinal = callsFinal.concat(tokenTypesByCampaign[campaign.campaignId].calls);
     }
     // Round 4: Get the final data
-    const resultsFinal = await batchMulticallCallWithRetry(chainId, {
-        calls: callsFinal,
-    });
+    const resultsFinal = await ChainInteractionService(chainId).fetchState(callsFinal);
     j = 0;
     let calls = [];
     for (const campaign of campaigns) {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.d.ts

@@ -1,4 +1,4 @@
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import type { CallDto } from "@sdk";
 export declare enum tokenType {
     aura = "aura",
     poolside = "poolside",
@@ -72,6 +72,6 @@ export declare const tokenTypeToProtocol: {
 };
 export type tokenTypeStruct = {
     type: tokenType;
-    calls: Multicall3.Call3Struct[];
+    calls: CallDto[];
     typeInfo: any;
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GenericProcessor.d.ts

@@ -1,6 +1,5 @@
 import type { Pricer } from "../../../../../utils/pricer";
-import { type Campaign, type CampaignParameters } from "@sdk";
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { type CallDto, type Campaign, type CampaignParameters } from "@sdk";
 import { type tokenType, type tokenTypeStruct } from "../helpers/tokenType";
 export declare enum roundType {
     one = "round1",
@@ -62,11 +61,11 @@ export declare class GenericProcessor<Input extends callKeys, DataRaw extends da
     computeRound3(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
     computeRound4(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;
     computeRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
-    generateWhitelistCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): Multicall3.Call3Struct[];
-    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): Multicall3.Call3Struct[];
+    generateWhitelistCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): CallDto[];
+    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): CallDto[];
     decodeListedSupply(index: number, decimals: number, list: string[], calls: string[]): string;
     decodeRound(round: callType[], index: number, calls: string[], type: tokenType, data: DataRaw): void;
     decodePreviousRound(round: roundType, calls: string[], data: DataRaw, type: tokenType, index: number): void;
-    encodeRound(round: callType[], callInfo: Input, type: tokenType): Multicall3.Call3Struct[];
-    encodeNextRound(round: roundType, type: tokenType, data: DataRaw): Multicall3.Call3Struct[];
+    encodeRound(round: callType[], callInfo: Input, type: tokenType): CallDto[];
+    encodeNextRound(round: roundType, type: tokenType, data: DataRaw): CallDto[];
 }

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1.d.ts

@@ -1,4 +1,3 @@
-import { type Campaign, type CampaignParameters } from "@sdk";
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { type Campaign, type CampaignParameters, type ResultDto } from "@sdk";
 import { type tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;
+export declare function getTokenTypeRound1(calls: ResultDto[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1.js

@@ -48,7 +48,8 @@ function satisfiesNameConditions(name, type) {
             return (lowerCaseName === "crvusd/frax" ||
                 lowerCaseName === "ezeth/wfrxeth" ||
                 lowerCaseName === "pufeth/wsteth" ||
-                lowerCaseName === "hai/lusd");
+                lowerCaseName === "hai/lusd" ||
+                lowerCaseName === "weth/pufeth");
         case tokenType.crosscurve:
             return lowerCaseName.startsWith("crosscurve") || lowerCaseName === "eywa/usdt";
         case tokenType.silostaking:

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound2.d.ts

@@ -1,3 +1,3 @@
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import type { ResultDto } from "@sdk";
 import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;
+export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: ResultDto[]): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound3.d.ts

@@ -1,3 +1,2 @@
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
 import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound3(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;
+export declare function getTokenTypeRound3(index: number, type: tokenType, typeInfo: any, calls: ResultDto[]): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound4.d.ts

@@ -1,4 +1,3 @@
-import type { Campaign, CampaignParameters } from "@sdk";
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import type { Campaign, CampaignParameters, ResultDto } from "@sdk";
 import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound4(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;
+export declare function getTokenTypeRound4(index: number, type: tokenType, typeInfo: any, calls: ResultDto[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;

package/dist/src/libs/campaigns/utils/fetchLogs.d.ts

@@ -1,4 +1,4 @@
-import type { MerklChainId } from "@sdk";
+import { type MerklChainId } from "@sdk";
 export type LogType = {
     data: string;
     topics: ReadonlyArray<string>;

package/dist/src/libs/campaigns/utils/fetchLogs.js

@@ -1,10 +1,28 @@
 import { log } from "../../../utils/logger";
 import { providers } from "../../../utils/providers";
+import { getContractCreationBlock } from "@sdk";
 import axios from "axios";
 async function fetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
     const url = providers[chainId].connection.url;
-    if (fromBlock === undefined || fromBlock === null || !toBlock) {
-        throw new Error("fromBlock and toBlock are required");
+    if (fromBlock === undefined || fromBlock === null || !toBlock || fromBlock > toBlock) {
+        throw new Error(`fromBlock and toBlock are required and fromBlock must be less than toBlock - fromBlock: ${fromBlock} - toBlock:${toBlock}`);
+    }
+    // Take the min of all address creation blocks
+    if (fromBlock === 0) {
+        let contractCreationBlock = toBlock;
+        for (const address of addresses) {
+            try {
+                const aux = await getContractCreationBlock(address, providers[chainId]);
+                if (aux < contractCreationBlock) {
+                    contractCreationBlock = aux;
+                }
+            }
+            catch {
+                contractCreationBlock = 0;
+                log.warn(`⚠️ couldn't get contract creation blocknumber for ${address}`);
+            }
+        }
+        fromBlock = contractCreationBlock;
     }
     const headers = {
         accept: "application/json",
@@ -12,11 +30,12 @@ async function fetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
     };
     let tempFromBlock = fromBlock;
     let tempToBlock = toBlock;
-    log.local(`fetching logs between blocks ${fromBlock} and ${toBlock}`);
+    log.info(`⏳ fetching logs between blocks ${fromBlock} and ${toBlock}`);
     let step = tempToBlock - tempFromBlock;
     // Binary search to fetch logs and avoid errors
     let logs = [];
     let isRateLimitingError = false;
+    // let stepLimited = false;
     while (true) {
         try {
             const data = {
@@ -25,9 +44,9 @@ async function fetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
                 method: "eth_getLogs",
                 params: [
                     {
-                        address: [...addresses],
+                        address: addresses,
                         topics: topics,
-                        fromBlock: `0x${(tempFromBlock + 1).toString(16)}`, // fromBlock is included
+                        fromBlock: `0x${(tempFromBlock).toString(16)}`, // fromBlock is included
                         toBlock: `0x${tempToBlock.toString(16)}`, // toBlock is included
                     },
                 ],
@@ -43,13 +62,17 @@ async function fetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
                 if (res.data.error?.code === 413) {
                     throw new Error("Request entity too large");
                 }
+                // Check if we hit the maximum log limit for a single call
                 if (res.data.result?.length === 10000)
                     throw new Error("Log size exceeded");
-                logs = logs.concat(...res.data.result);
-                log.local(`fetched ${res.data.result.length} logs between blocks ${tempFromBlock} and ${tempToBlock}`);
+                const logsBatch = res.data.result || [];
+                logs = logs.concat(...logsBatch);
+                const batchSize = logsBatch.length;
+                const blockRange = tempToBlock - tempFromBlock + 1;
+                log.local(`fetched ${batchSize} logs between blocks ${tempFromBlock} and ${tempToBlock} (block range: ${blockRange})`);
             }
             catch (e) {
-                if (e.toString() === "Error: Request failed with status code 429") {
+                if (e instanceof Error && e.toString() === "Error: Request failed with status code 429") {
                     isRateLimitingError = true;
                 }
                 if (isRateLimitingError) {
@@ -59,11 +82,11 @@ async function fetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
                 }
                 const message = `error making POST request: ${e}`;
                 log.error("fetchLogs", message);
-                throw message;
+                throw new Error(message);
             }
             if (tempToBlock === toBlock)
                 break;
-            tempFromBlock = Math.min(tempFromBlock + step, toBlock);
+            tempFromBlock = Math.min(tempToBlock + 1, toBlock);
             tempToBlock = Math.min(tempToBlock + step, toBlock);
         }
         catch {
@@ -74,7 +97,7 @@ async function fetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
                 isRateLimitingError = false;
             }
             if (step === 0) {
-                log.error("fetchLogs", `error fetching logs for ${addresses}`);
+                log.error("❌ fetchLogs", `error fetching logs for ${addresses}`);
                 return { logs, block: tempFromBlock };
             }
             tempToBlock = tempFromBlock + step;

package/dist/src/libs/campaigns/utils/getCompV2ForksVaults.js

@@ -1,5 +1,6 @@
 import { Redis } from "../../../cache";
 import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { log } from "../../../utils/logger";
 import { providers } from "../../../utils/providers";
 import { CTokenInterface, ChainId, CompFork, Comptrollers, ERC20Interface, NULL_ADDRESS, } from "@sdk";
 import { defaultAbiCoder } from "ethers/lib/utils";
@@ -15,6 +16,7 @@ async function getCompoundV2ForksVaults() {
             if ([ChainId.LINEA].includes(chainId)) {
                 continue;
             }
+            log.local(`Fetching Compound V2 vaults for chainId ${ChainId[chainId]} and compFork ${CompFork[compFork]}`);
             const toBlock = await providers[chainId].getBlockNumber();
             const comptrollerAddress = Comptrollers[compFork][chainId];
             if (!comptrollerAddress) {

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

@@ -9,23 +9,32 @@ export class AprService {
         const typesWithoutApr = [CampaignTypeV3.INVALID, CampaignTypeV3.JSON_AIRDROP, CampaignTypeV3.ERC20_SNAPSHOT];
         if (typesWithoutApr.includes(type))
             return { timestamp, cumulated: 0, breakdowns: [] };
-        let cumulated = campaignsDynamicData.reduce((sum, campaign) => sum + (Number.isNaN(Number(campaign.apr)) ? 0 : Number(campaign.apr)), 0) ?? 0;
+        let cumulated = campaignsDynamicData.reduce((sum, campaign) => {
+            const isLive = BigInt(campaign.endTimestamp) > timestamp && BigInt(campaign.startTimestamp) < timestamp;
+            if (!isLive)
+                return sum;
+            return sum + (Number.isNaN(Number(campaign.apr)) ? 0 : Number(campaign.apr));
+        }, 0) ?? 0;
         cumulated = Number.isNaN(Number(cumulated)) || !Number.isFinite(cumulated) ? 0 : cumulated;
         const breakdowns = campaignsDynamicData.map(campaign => {
+            const isLive = BigInt(campaign.endTimestamp) > timestamp && BigInt(campaign.startTimestamp) < timestamp;
             return {
                 identifier: campaign.campaignId,
                 type: AprType.CAMPAIGN,
-                value: Number.isNaN(campaign.apr) || !Number.isFinite(campaign.apr) ? 0 : Number(campaign.apr),
+                value: !isLive || Number.isNaN(campaign.apr) || !Number.isFinite(campaign.apr) ? 0 : Number(campaign.apr),
             };
         });
         if (type === CampaignTypeV3.CLAMM) {
             for (const campaign of campaignsDynamicData) {
+                const isLive = BigInt(campaign.endTimestamp) > timestamp && BigInt(campaign.startTimestamp) < timestamp;
                 if (campaign.forwarders) {
                     for (const forwarder of campaign.forwarders) {
                         breakdowns.push({
                             identifier: forwarder.label,
                             type: AprType.PROTOCOL,
-                            value: Number.isNaN(forwarder.almAPR) || !Number.isFinite(forwarder.almAPR) ? 0 : Number(forwarder.almAPR),
+                            value: !isLive || Number.isNaN(forwarder.almAPR) || !Number.isFinite(forwarder.almAPR)
+                                ? 0
+                                : Number(forwarder.almAPR),
                         });
                     }
                 }

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

@@ -12,7 +12,7 @@ export class DynamicDataService {
                 amount: "1000000000000000000", // 1 EXR in wei
                 campaignSubType: 0,
                 chainId: chainId,
-                computeChainId: 1,
+                computeChainId: chainId,
                 creator: "0xexamplecreatoraddress",
                 endTimestamp: 1672531199, // Example end timestamp
                 index: 0,

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

@@ -140,6 +140,9 @@ export class ProgramPayloadService {
                 const queryCampaign = { ...query, campaign, amount: amount };
                 campaignPayloads = ProgramPayloadService.buildPayload(queryCampaign, campaignPayloads);
             }
+            else {
+                throw new Error(`Campaign ${campaign} not found`);
+            }
         }
         return campaignPayloads;
     }

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

@@ -2,7 +2,7 @@ import type Elysia from "elysia";
 export declare const query: import("@sinclair/typebox").TObject<{
     chainIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
     user: import("@sinclair/typebox").TString;
-    creatorTag: import("@sinclair/typebox").TString;
+    creatorTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 declare const _default: (app: Elysia) => Elysia<"", false, {
     decorator: {};
@@ -23,8 +23,8 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
             params: {};
             query: {
                 chainIds?: string | string[] | undefined;
+                creatorTag?: string | undefined;
                 user: string;
-                creatorTag: string;
             };
             headers: unknown;
             response: {

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

@@ -8,7 +8,7 @@ import { throwOnUnsupportedChainId } from "../../utils/throw";
 export const query = t.Object({
     chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
     user: t.String(),
-    creatorTag: t.String(),
+    creatorTag: t.Optional(t.String()),
 });
 export default (app) => app.use(checkQueryAddressValidity()).get("/multiChainPositions", async ({ query, set }) => {
     let rawChainIds = query.chainIds;

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

@@ -379,8 +379,8 @@ export declare const v3: Elysia<"/v3", false, {
                 params: {};
                 query: {
                     chainIds?: string | string[] | undefined;
+                    creatorTag?: string | undefined;
                     user: string;
-                    creatorTag: string;
                 };
                 headers: unknown;
                 response: {

package/dist/src/utils/encodeCalls.d.ts

@@ -1,3 +1,3 @@
 import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
-import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
-export declare function createCall(target: string, key: string, type?: tokenType, metaData?: any): Multicall3.Call3Struct;
+import { type CallDto } from "@sdk";
+export declare function createCall(target: string, key: string, type?: tokenType, metaData?: any): CallDto;