@merkl/api 0.9.15

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

@@ -0,0 +1,249 @@
+import { BucketService } from "@/modules/v4/bucket/bucket.service";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { engineDbClient } from "@db";
+import { BN2Number, ChainInteractionService, EAprBreakdownType, NETWORK_LABELS, UniswapV4Addresses, UniswapV4StateViewInterface, getSqrtRatioAtTick, shortenAddress, } from "@sdk";
+import moment from "moment";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+// Constants
+const CALLS_LENGTH = 2;
+/**
+ * Compute TVL
+ * @dev important: using the most recent state save with current prices
+ *      it's only an estimate
+ */
+async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID, priceCurrency0, priceCurrency1, decimalsCurrency0, decimalsCurrency1) {
+    let stateSave;
+    let blockNumber;
+    let states = {};
+    try {
+        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
+        const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
+            where: {
+                id: `UniswapV4_${chainId}_${poolID}`,
+                blockNumber: {
+                    lte: currentBlock,
+                },
+            },
+            orderBy: {
+                blockNumber: "desc",
+            },
+        });
+        stateSave = mostRecentStateSave.state;
+        blockNumber = mostRecentStateSave?.blockNumber;
+        states = stateSave.states;
+        // const globalState = stateSave.globalState as { tick: number; liquidity: string };
+    }
+    catch (e) {
+        log.warn(`merklDynamic data - failed to read a recent state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
+    }
+    const { fileName, bucketName } = states;
+    // Bucket service
+    let tvl = 0;
+    let amount0 = 0;
+    let amount1 = 0;
+    try {
+        const bucket = new BucketService(bucketName, "merkl-production");
+        const storedStates = JSON.parse(await bucket.pull(fileName));
+        for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
+            amount0 += BN2Number(value.amount0, decimalsCurrency0);
+            amount1 += BN2Number(value.amount1, decimalsCurrency1);
+        }
+        tvl = amount0 * (priceCurrency0 ?? 0) + amount1 * (priceCurrency1 ?? 0);
+    }
+    catch (e) {
+        console.log(e);
+        log.warn(`merklDynamic data - failed to decode state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
+    }
+    return { tvl, amount0, amount1, blockNumber: blockNumber };
+}
+export class UniswapV4DynamicData {
+    async build(chainId, campaigns) {
+        const dynamicData = [];
+        const pricer = await Pricer.load();
+        const calls = [];
+        /** Dedupe pools from campaigns to build pool list */
+        const poolList = [];
+        for (const campaign of campaigns ?? []) {
+            /** Loop through all campaigns to add pools */
+            if (!poolList?.map(p => p.mainParameter.toLowerCase()).includes(campaign.mainParameter.toLowerCase())) {
+                poolList.push({
+                    poolId: campaign.campaignParameters.poolId,
+                    mainParameter: campaign.mainParameter, // FIXME
+                });
+            }
+        }
+        if (!!poolList) {
+            for (const pool of poolList) {
+                calls.push({
+                    allowFailure: true,
+                    callData: UniswapV4StateViewInterface.encodeFunctionData("getLiquidity", [pool.poolId]),
+                    target: UniswapV4Addresses[chainId].StateView,
+                }, {
+                    allowFailure: true,
+                    callData: UniswapV4StateViewInterface.encodeFunctionData("getSlot0", [pool.poolId]),
+                    target: UniswapV4Addresses[chainId].StateView,
+                });
+            }
+            const result = await ChainInteractionService(chainId).fetchState(calls);
+            let i = 0;
+            if (!!poolList) {
+                for (const pool of poolList) {
+                    // This liquidity call gives the active liquidity on the pool. To get the total liquidity we would need to loop over all positions
+                    let poolTotalLiquidity;
+                    let sqrtPrice;
+                    let tick;
+                    let poolBalanceToken0 = 0;
+                    let poolBalanceToken1 = 0;
+                    const campaignsForPool = campaigns?.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase());
+                    const prevI = i;
+                    try {
+                        poolTotalLiquidity = UniswapV4StateViewInterface.decodeFunctionResult("getLiquidity", result[i++].returnData)[0].toString();
+                        const poolData = UniswapV4StateViewInterface.decodeFunctionResult("getSlot0", result[i++].returnData);
+                        tick = poolData.tick;
+                        sqrtPrice = getSqrtRatioAtTick(tick).toString();
+                    }
+                    catch {
+                        log.warn(`merklDynamic data - failed to decode state of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                        i = prevI + CALLS_LENGTH;
+                        continue;
+                    }
+                    const decimalsCurrency0 = campaignsForPool[0].campaignParameters.decimalsCurrency0;
+                    const decimalsCurrency1 = campaignsForPool[0].campaignParameters.decimalsCurrency1;
+                    const symbolCurrency0 = campaignsForPool[0].campaignParameters.symbolCurrency0;
+                    const symbolCurrency1 = campaignsForPool[0].campaignParameters.symbolCurrency1;
+                    const priceToken0 = (await pricer.get({
+                        address: campaignsForPool[0].campaignParameters.currency0,
+                        chainId: chainId,
+                        symbol: symbolCurrency0,
+                    }));
+                    const priceToken1 = (await pricer.get({
+                        address: campaignsForPool[0].campaignParameters.currency1,
+                        chainId: chainId,
+                        symbol: symbolCurrency1,
+                    }));
+                    const { tvl, amount0, amount1, blockNumber } = await computeUniV4PoolTVLFromMostRecentStateSave(chainId, pool.poolId, priceToken0, priceToken1, decimalsCurrency0, decimalsCurrency1);
+                    poolBalanceToken0 += amount0;
+                    poolBalanceToken1 += amount1;
+                    /** Iterate over distributions to compute APRs */
+                    for (const campaign of campaignsForPool) {
+                        const c = campaign;
+                        const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
+                        const startTimestamp = BN2Number(c.startTimestamp, 0);
+                        const endTimestamp = BN2Number(c.endTimestamp, 0);
+                        const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
+                        const totalWeight = BN2Number(c.campaignParameters.weightFees, 4) +
+                            BN2Number(c.campaignParameters.weightToken0, 4) +
+                            BN2Number(c.campaignParameters.weightToken1, 4);
+                        // Proportions in percentage
+                        const propFees = (BN2Number(c.campaignParameters.weightFees, 4) / totalWeight) * 100;
+                        const propToken0 = (BN2Number(c.campaignParameters.weightToken0, 4) / totalWeight) * 100;
+                        const propToken1 = (BN2Number(c.campaignParameters.weightToken1, 4) / totalWeight) * 100;
+                        let distributionMeanAPR = 0;
+                        const blacklistedBalance0 = 0;
+                        const blacklistedBalance1 = 0;
+                        const blacklistedLiquidity = 0;
+                        const aprs = {};
+                        const aprBreakdowns = [];
+                        let priceRewardToken = 0;
+                        if (isLive && c.campaignParameters.symbolRewardToken !== "aglaMerkl") {
+                            // priceRewardToken = (await pricer.get({
+                            //   address: c.rewardToken,
+                            //   chainId: chainId,
+                            //   symbol: c.campaignParameters.symbolRewardToken,
+                            // })) as number;
+                            priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                            /**
+                             * Handle whitelisted/blacklisted addresses to compute APR
+                             */
+                            if (c.campaignParameters.whitelist.length > 0) {
+                                // TODO
+                            }
+                            else if (c.campaignParameters.blacklist.length > 0) {
+                                // TODO
+                            }
+                            /** Yearly rewards in $ */
+                            const yearlyToken0Rewards = (propToken0 * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
+                            const yearlyToken1Rewards = (propToken1 * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
+                            const yearlyFeeRewards = (propFees * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
+                            let poolAPRkey = "";
+                            /**
+                             * General APR (@notice potentially with a boost)
+                             */
+                            const poolBalanceToken0WithoutBlacklist = poolBalanceToken0;
+                            const poolBalanceToken1WithoutBlacklist = poolBalanceToken1;
+                            //   const poolLiquidityWithoutBlacklist = poolTotalLiquidity - (blacklistedLiquidity ?? 0);
+                            const tvl = poolBalanceToken0WithoutBlacklist * priceToken0 + poolBalanceToken1WithoutBlacklist * priceToken1;
+                            distributionMeanAPR = (yearlyToken0Rewards + yearlyToken1Rewards + yearlyFeeRewards) / tvl;
+                            distributionMeanAPR = !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
+                            /**
+                             * @dev We cannot include a whitelisted distrib apr into the mean APR
+                             */
+                            if (c.campaignParameters.whitelist.length === 0) {
+                                poolAPRkey = "Average APR (rewards / pool TVL)";
+                                if (!aprs[poolAPRkey])
+                                    aprs[poolAPRkey] = 0;
+                                aprs[poolAPRkey] += distributionMeanAPR;
+                                // @Hugo wip: new way to structure aprBreakdowns
+                                aprBreakdowns.push({
+                                    address: pool.poolId,
+                                    value: distributionMeanAPR,
+                                    type: EAprBreakdownType.AVERAGE,
+                                    label: "Average APR (rewards / pool TVL)",
+                                });
+                                // APR per token
+                                poolAPRkey = `APR for holding ${c.campaignParameters.symbolCurrency0} in pool`;
+                                if (!aprs[poolAPRkey])
+                                    aprs[poolAPRkey] = 0;
+                                aprs[poolAPRkey] += yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0);
+                                // @Hugo wip: new way to structure aprBreakdowns
+                                aprBreakdowns.push({
+                                    address: pool.poolId,
+                                    value: yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0),
+                                    type: EAprBreakdownType.TOKEN1,
+                                    label: c.campaignParameters.symbolCurrency0,
+                                });
+                                poolAPRkey = `APR for holding  ${c.campaignParameters.symbolCurrency1} in pool`;
+                                if (!aprs[poolAPRkey])
+                                    aprs[poolAPRkey] = 0;
+                                aprs[poolAPRkey] += yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1);
+                                // @Hugo wip: new way to structure aprBreakdowns
+                                aprBreakdowns.push({
+                                    address: pool.poolId,
+                                    value: yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1),
+                                    type: EAprBreakdownType.TOKEN2,
+                                    label: c.campaignParameters.symbolCurrency1,
+                                });
+                            }
+                            else {
+                                for (const _ of c.campaignParameters.whitelist) {
+                                    const poolAPRkey = `Whitelisted campaign on UniswapV4 via address ${shortenAddress(c.campaignParameters.whitelist[0])} Average APR`;
+                                    if (!aprs[poolAPRkey])
+                                        aprs[poolAPRkey] = 0;
+                                }
+                                aprs[poolAPRkey] += distributionMeanAPR;
+                            }
+                        }
+                        dynamicData.push({
+                            ...campaign,
+                            apr: distributionMeanAPR,
+                            aprs,
+                            aprBreakdowns,
+                            blacklistedBalance0,
+                            blacklistedBalance1,
+                            blacklistedLiquidity,
+                            poolBalanceToken0,
+                            poolBalanceToken1,
+                            poolTotalLiquidity,
+                            sqrtPrice,
+                            tick: tick,
+                            priceRewardToken: priceRewardToken,
+                            tvl: poolBalanceToken0 * priceToken0 + poolBalanceToken1 * priceToken1,
+                        });
+                    }
+                }
+            }
+        }
+        return dynamicData;
+    }
+}

package/dist/src/engine/dynamicData/implementations/Vest.d.ts

@@ -0,0 +1,9 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+export declare const VEST_TREASURY = "0x7ccF5BbeC69c790D27dA3b5398B9e0d6D6EeC9F3";
+export declare const VEST_TOKEN = "0x3355df6D4c9C3035724Fd0e3914dE96A5a83aaf4";
+type campaignType = Campaign.VEST;
+export declare class VestDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<VestCampaignDynamicData[]>;
+}
+export {};

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

@@ -0,0 +1,58 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { BN2Number, ChainInteractionService, ERC20Interface, YEAR, } from "@sdk";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+export const VEST_TREASURY = "0x7ccF5BbeC69c790D27dA3b5398B9e0d6D6EeC9F3";
+export const VEST_TOKEN = "0x3355df6D4c9C3035724Fd0e3914dE96A5a83aaf4";
+export class VestDynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        const calls = [];
+        for (const _campaign of campaigns) {
+            calls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("balanceOf", [VEST_TREASURY]),
+                target: VEST_TOKEN,
+            });
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            let totalSupply;
+            try {
+                totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i++].returnData)[0], 6);
+            }
+            catch {
+                log.warn(`Error getting totalSupply for campaign ${campaign.campaignId}`);
+                totalSupply = 0.0000001;
+            }
+            // const priceRewardToken =
+            //   (await pricer.get({
+            //     address: campaign.rewardToken,
+            //     chainId: campaign.chainId,
+            //     symbol: campaign.campaignParameters.symbolRewardToken,
+            //   })) ?? 0;
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            const priceTargetToken = (await pricer.get({
+                address: VEST_TOKEN,
+                chainId: campaign.computeChainId,
+                symbol: "USDC.e",
+            })) ?? 0;
+            const tvl = totalSupply * priceTargetToken;
+            dynamicData.push({
+                ...campaign,
+                apr: (priceRewardToken *
+                    BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                    YEAR *
+                    100) /
+                    campaign.campaignParameters.duration /
+                    (totalSupply * priceTargetToken),
+                totalSupplyTargetToken: totalSupply,
+                tvl,
+                priceRewardToken: priceRewardToken,
+            });
+        }
+        return dynamicData;
+    }
+}

package/dist/src/engine/dynamicData/implementations/default.d.ts

@@ -0,0 +1,5 @@
+import type { Campaign as CampaignEnum, CampaignParameters, MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+export declare class DefaultDynamicData implements DynamicDataBuilder<CampaignEnum> {
+    build(_chainId: MerklChainId, campaigns: CampaignParameters<CampaignEnum>[]): Promise<CampaignParameters<CampaignEnum>[]>;
+}

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

@@ -0,0 +1,5 @@
+export class DefaultDynamicData {
+    async build(_chainId, campaigns) {
+        return campaigns;
+    }
+}

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

@@ -0,0 +1,18 @@
+import { type MerklChainId } from "@sdk";
+export declare type A51StrategiesType = {
+    pool: string;
+    vault: string;
+    id: string;
+    tickLower: number;
+    tickUpper: number;
+};
+export type A51StrategiesReturnType = {
+    [pool: string]: {
+        [vault: string]: {
+            id: string;
+            tickLower: number;
+            tickUpper: number;
+        }[];
+    };
+};
+export declare function fetchA51Strategies(chainId: MerklChainId, pools: string[]): Promise<A51StrategiesReturnType>;

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

@@ -0,0 +1,44 @@
+import { ALM, NETWORK_LABELS, merklSubgraphALMEndpoints, withTimeout } from "@sdk";
+import { gql, request } from "graphql-request";
+import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "../../../constants";
+import { log } from "../../../utils/logger";
+const A51StrategiesQuery = gql `
+  query Strategies($pool_in: [String]) {
+    strategies: strategies(where: { pool_in: $pool_in }, first: 1000) {
+        pool
+        vault
+        id
+        tickLower
+        tickUpper
+    }
+  }
+`;
+export async function fetchA51Strategies(chainId, pools) {
+    const tgURL = merklSubgraphALMEndpoints[chainId][ALM.A51];
+    const res = {};
+    if (!!tgURL && tgURL !== "") {
+        await withTimeout(request(tgURL, A51StrategiesQuery, {
+            pool_in: pools,
+        }), MERKL_USER_POSITION_FETCHING_TIMEOUT)
+            .then(fetchedData => {
+            for (const strategy of fetchedData.strategies) {
+                const pool = strategy.pool.toLowerCase();
+                const vault = strategy.vault.toLowerCase();
+                if (!res[pool])
+                    res[pool] = {};
+                if (!res[pool][vault])
+                    res[pool][vault] = [];
+                res[pool][vault].push({
+                    id: strategy.id,
+                    tickLower: strategy.tickLower,
+                    tickUpper: strategy.tickUpper,
+                });
+            }
+        })
+            .catch(error => {
+            const service = `Merkl ALM Subgraph for ${NETWORK_LABELS[chainId]} A51`;
+            log.error(service, error, service, tgURL);
+        });
+    }
+    return res;
+}

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

@@ -0,0 +1,12 @@
+import { type MerklChainId } from "@sdk";
+export type AmbientHolderType = {
+    owner: string;
+    base: string;
+    quote: string;
+    poolIdx: number;
+    lowerTick: number;
+    upperTick: number;
+    positionType: string;
+};
+export declare const holdersQuery: string;
+export declare function fetchAmbientPotentialPositions(poolId: string, chainId: MerklChainId): Promise<AmbientHolderType[]>;

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

@@ -0,0 +1,59 @@
+import { subgraphAmbientEndpoints, withRetry } from "@sdk";
+import { gql, request } from "graphql-request";
+const BATCH_NUMBER = 1000;
+export const holdersQuery = gql `
+  query LiquidityChanges($poolId: String!, $minId: String!) {
+    liquidityChanges(
+      where: { pool_: { id: $poolId }, id_gt: $minId , positionType_not: "knockout"},
+      first: ${BATCH_NUMBER},
+      orderBy: pool__id
+    ) {
+      id  
+      user
+      positionType
+      bidTick
+      askTick
+      pool {
+        base
+        quote
+        poolIdx
+      }
+    }
+  }
+  `;
+export async function fetchAmbientPotentialPositions(poolId, chainId) {
+    let isFullyFetched = false;
+    let holders = [];
+    let minId = "";
+    while (!isFullyFetched) {
+        const data = await withRetry(request, [
+            subgraphAmbientEndpoints[chainId],
+            holdersQuery,
+            {
+                poolId: poolId,
+                minId: minId,
+            },
+        ]);
+        const fetchedHolders = data.liquidityChanges?.map(entry => {
+            return {
+                owner: entry.user,
+                base: entry.pool.base,
+                quote: entry.pool.quote,
+                poolIdx: Number(entry.pool.poolIdx),
+                lowerTick: Number(entry.bidTick),
+                upperTick: Number(entry.askTick),
+                positionType: entry.positionType,
+            };
+        });
+        if (fetchedHolders.length < BATCH_NUMBER) {
+            isFullyFetched = true;
+        }
+        else {
+            minId = data.liquidityChanges[fetchedHolders.length - 1].id;
+        }
+        holders = holders.concat(fetchedHolders);
+    }
+    // Only keep unique positions
+    holders = Array.from(new Set(holders.map(h => JSON.stringify(h)))).map(h => JSON.parse(h));
+    return holders;
+}

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

@@ -0,0 +1,2 @@
+import type { Campaigns } from "@db/engine";
+export declare function fetchClamInfo(campaigns: Campaigns[]): Promise<void>;

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

@@ -0,0 +1,27 @@
+export async function fetchClamInfo(campaigns) {
+    // split the campaigns by chainId and pool
+    const campaignsByChainIdAndPool = {};
+    // mainParameter is the pool for CLAMs
+    campaigns.forEach(campaign => {
+        const { chainId, mainParameter } = campaign;
+        if (!campaignsByChainIdAndPool[chainId]) {
+            campaignsByChainIdAndPool[chainId] = {};
+        }
+        if (!campaignsByChainIdAndPool[chainId][mainParameter]) {
+            campaignsByChainIdAndPool[chainId][mainParameter] = [];
+        }
+        campaignsByChainIdAndPool[chainId][mainParameter].push(campaign);
+    });
+    // Get the raw pool info for each chain
+    // Get the ALM positions for each pool
+    // BalanceOf Token0
+    // BalanceOf Token1
+    // Price Token0 --> from prices
+    // Price Token1 --> from prices
+    // What I need
+    // Pool
+    // TVL token0
+    // TVL token1
+    // ALM Positions (ALM ID --> address + amount)
+    // Get the
+}

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

@@ -0,0 +1,10 @@
+import { type MerklChainId } from "@sdk";
+export type LogType = {
+    data: string;
+    topics: ReadonlyArray<string>;
+    blockNumber: string;
+    address: string;
+    blockHash: string;
+    logIndex: string;
+};
+export declare function safeFetchLogs(chainId: MerklChainId, topics: string[], addresses: string[], fromBlock: number, toBlock: number): Promise<LogType[]>;

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

@@ -0,0 +1,149 @@
+import { log } from "@/utils/logger";
+import { ChainId, ChainInteractionService, getContractCreationBlock } from "@sdk";
+import axios from "axios";
+async function fetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
+    const url = ChainInteractionService(chainId).provider().connection.url;
+    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, ChainInteractionService(chainId).provider());
+                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",
+        "content-type": "application/json",
+    };
+    let tempFromBlock = fromBlock;
+    let tempToBlock = toBlock;
+    log.info(`⏳ fetching logs between blocks ${fromBlock} and ${toBlock}`);
+    let step = tempToBlock - tempFromBlock;
+    // Binary search to fetch logs and avoid errors
+    let logs = [];
+    // Binary search to fetch logs and avoid errors
+    let isRateLimitingError = false;
+    let stepLimited = false;
+    const maxLogsPerRequest = 10_000;
+    while (true) {
+        try {
+            const data = {
+                id: 1,
+                jsonrpc: "2.0",
+                method: "eth_getLogs",
+                params: [
+                    {
+                        address: addresses,
+                        topics: topics,
+                        fromBlock: `0x${(tempFromBlock).toString(16)}`, // fromBlock is included
+                        toBlock: `0x${tempToBlock.toString(16)}`, // toBlock is included
+                    },
+                ],
+            };
+            try {
+                const res = await axios.post(url, data, { headers });
+                if (res?.data?.error?.code === -32602)
+                    throw new Error("Log size exceeded");
+                if (res.data.error?.code === 429) {
+                    isRateLimitingError = true;
+                    throw new Error("Rate Limiting");
+                }
+                if (res.data.error?.code === 413) {
+                    throw new Error("Request entity too large");
+                }
+                if (res.data.error?.code === -32000 && chainId === ChainId.AVALANCHE) {
+                    stepLimited = true;
+                    step = 2047 * 2;
+                    throw new Error("Block width exceeded");
+                }
+                if (res.data.error?.code === -32000 && chainId === ChainId.BSC) {
+                    // Reall error is: " block not found x"
+                    throw new Error("Log size exceeded");
+                }
+                // Check if we hit the maximum log limit for a single call
+                if (res.data.result?.length === 10000)
+                    throw new Error("Log size exceeded");
+                const logsBatch = res.data.result || [];
+                logs = logs.concat(...logsBatch);
+                const batchSize = logsBatch.length;
+                const blockRange = tempToBlock - tempFromBlock + 1;
+                if (!stepLimited) {
+                    if (batchSize === 0) {
+                        // Add safeguard for 0 logs case
+                        // If no logs found, increase step size
+                        step = Math.floor(step * 2);
+                    }
+                    else {
+                        // Aggressive adjustment based on how far we are from optimal logs per request
+                        const optimalLogsPerRequest = maxLogsPerRequest * 0.7; // Target 70% of max logs per request
+                        const logsPerRequestRatio = batchSize / optimalLogsPerRequest;
+                        if (batchSize < maxLogsPerRequest * 0.8) {
+                            // More aggressive adjustment when far from target
+                            const adjustmentFactor = (1 / logsPerRequestRatio) ** 0.7; // Non-linear scaling
+                            step = Math.floor(step * adjustmentFactor);
+                            // Allow for larger jumps when log density is very low
+                            if (logsPerRequestRatio < 0.2) {
+                                step = Math.floor(step * 2);
+                            }
+                        }
+                        else {
+                            // Quick reduction when close to limit
+                            step = Math.floor(step * 0.4);
+                        }
+                    }
+                }
+                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") {
+                    isRateLimitingError = true;
+                }
+                if (isRateLimitingError) {
+                    /** Sleeping to reduce the chances of being rate limited */
+                    await new Promise(resolve => setTimeout(resolve, 10_000));
+                    throw new Error("Rate Limiting");
+                }
+                const message = `error making POST request: ${e}`;
+                log.error("fetchLogs", message);
+                throw new Error(message);
+            }
+            if (tempToBlock === toBlock)
+                break;
+            tempFromBlock = Math.min(tempToBlock + 1, toBlock);
+            tempToBlock = Math.min(tempToBlock + step, toBlock);
+        }
+        catch {
+            if (!isRateLimitingError) {
+                step = Math.floor(step / 2);
+            }
+            else {
+                isRateLimitingError = false;
+            }
+            if (step === 0) {
+                log.error("❌ fetchLogs", `error fetching logs for ${addresses} on ${ChainId[chainId]}`);
+                return { logs, block: tempFromBlock };
+            }
+            tempToBlock = tempFromBlock + step;
+        }
+    }
+    return { logs, block: toBlock };
+}
+export async function safeFetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
+    const { logs, block } = await fetchLogs(chainId, topics, addresses, fromBlock, toBlock);
+    if (block !== toBlock) {
+        throw new Error(`error fetching logs for ${addresses}`);
+    }
+    return logs;
+}