@merkl/api 0.9.15

package/dist/src/utils/execute.js

@@ -0,0 +1,117 @@
+// @ts-nocheck
+import { MAX_NUM_SUBCALLS } from "@/constants";
+import { withRetry } from "@sdk";
+import { constants } from "ethers";
+import { log } from "./logger";
+import { archiveMulticalls, multicalls } from "./providers";
+/**
+ * Functions
+ */
+export async function executeSimple(chainId, componentCall) {
+    const c = await componentCall;
+    if (c.cached === true)
+        return c.result;
+    return (await execute(chainId, [c.call]))[0];
+}
+const execute = async (chainId, callList, shouldRetry, blockNumber) => {
+    const calls = [];
+    for (const subCall of callList) {
+        calls.push(...subCall.callData);
+    }
+    try {
+        let result;
+        if (calls.length > 0) {
+            result = await batchMulticallCall(multicallContractCall, !!blockNumber ? archiveMulticalls[chainId] : multicalls[chainId], { blockNumber: blockNumber, data: calls }, shouldRetry);
+        }
+        else {
+            result = [];
+        }
+        let startIndex = 0;
+        const promises = [];
+        for (const subCall of callList) {
+            promises.push(subCall.reducer(result.slice(startIndex, startIndex + subCall.callData.length)));
+            startIndex += subCall.callData.length;
+        }
+        return await Promise.all(promises);
+    }
+    catch (e) {
+        for (const subCall of callList) {
+            log.error("execute", e);
+            subCall.handler();
+        }
+    }
+    return [];
+};
+async function multicallContractCall(contract, args) {
+    let result;
+    try {
+        // TO SIMULATE - USE CAUTIOUSLY AS IT USES CREDITS
+        // console.log(
+        //   await callTenderly(
+        //     {
+        //       chainId: (await contract.provider.getNetwork()).chainId.toString(),
+        //       data: contract.interface.encodeFunctionData('aggregate', [args.data]),
+        //       from: !!args.from ? args.from : constants.AddressZero,
+        //       saveSimulation: true,
+        //       to: contract.address,
+        //       value: '0',
+        //     },
+        //     undefined,
+        //     true
+        //   )
+        // );
+        result = await contract.provider.call({
+            data: contract.interface.encodeFunctionData("aggregate3", [
+                args.data.map(c => {
+                    return {
+                        allowFailure: !!c.allowFailure,
+                        callData: c.callData,
+                        target: c.target,
+                    };
+                }),
+            ]),
+            from: !!args.from ? args.from : constants.AddressZero,
+            to: contract.address,
+        }, !!args.blockNumber ? args.blockNumber : undefined);
+    }
+    catch (e) {
+        log.error("multicallContractCall failed", e);
+        throw new Error("❌ failed to decode multicall data");
+    }
+    return contract.interface.decodeFunctionResult("aggregate3", result)[0].map((r) => r?.returnData);
+}
+async function batchMulticallCall(func, contract, args, shouldRetry = true) {
+    let callsLeft = args.data.length;
+    let lowerIdx = 0;
+    let upperIdx = Math.min(args.data.length, MAX_NUM_SUBCALLS);
+    const multicallBatch = [];
+    while (callsLeft !== 0) {
+        multicallBatch.push(shouldRetry
+            ? withRetry(func, [
+                // TODO: fix typing
+                contract,
+                {
+                    blockNumber: args.blockNumber,
+                    data: args.data.slice(lowerIdx, upperIdx),
+                },
+            ])
+            : func(contract, args));
+        callsLeft -= upperIdx - lowerIdx;
+        lowerIdx = upperIdx;
+        upperIdx = Math.min(args.data.length, upperIdx + MAX_NUM_SUBCALLS);
+    }
+    /** Executing batched multicall */
+    const results = await Promise.allSettled(multicallBatch);
+    let fetchedData = [];
+    for (let k = 0; k < results.length; k++) {
+        const res = results[k];
+        if (res.status === "fulfilled") {
+            fetchedData = fetchedData.concat(res.value);
+        }
+        else {
+            log.error(`batchMulticallCall failed to ${args.data[k].target}, data: ${args.data[k].callData}`, res);
+            fetchedData.concat("0x");
+        }
+    }
+    return fetchedData;
+}

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

@@ -0,0 +1,6 @@
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { type Campaign, type CampaignParameters } from "@sdk";
+export declare const stakingContractToStakingSymbol: {
+    [key: string]: string;
+};
+export declare function generateCardName(type: tokenType, typeInfo: any, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, symbols?: string[], displayName?: string): string;

package/dist/src/utils/generateCardName.js

@@ -0,0 +1,198 @@
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { ChainId } from "@sdk";
+export const stakingContractToStakingSymbol = {
+    "0x18eeD20f71BEf84B605253C89A7576E3634134C0": "CyberStaking",
+    "0x68754d29f2e97B837Cb622ccfF325adAC27E9977": "Karak",
+    "0xcd28cF8f7755f03967D27E128B38022B63919836": "Llamalend",
+};
+export function generateCardName(type, typeInfo, campaign, symbols = [""], displayName) {
+    if (typeInfo.isStaking === "true") {
+        if (typeInfo.stakingName !== undefined) {
+            typeInfo.stakingSymbol = typeInfo.stakingName.includes("Deposit")
+                ? typeInfo.stakingName.replace("Deposit", "").trim()
+                : typeInfo.stakingName;
+        }
+        if (typeInfo.stakingSymbol === undefined) {
+            typeInfo.stakingSymbol = typeInfo.eip712DomainName;
+        }
+        if (typeInfo.stakingSymbol === undefined) {
+            typeInfo.stakingSymbol = typeInfo.protocol !== "Unknown" ? typeInfo.protocol : undefined;
+        }
+        if (typeInfo.stakingSymbol === undefined) {
+            typeInfo.stakingSymbol = stakingContractToStakingSymbol[typeInfo.stakingContract];
+        }
+        return `${typeInfo.lockNFT !== undefined ? "Lock" : "Stake"} ${campaign.campaignParameters.symbolTargetToken} on ${typeInfo.stakingSymbol}`;
+    }
+    switch (type) {
+        case tokenType.uniswapv2:
+        case tokenType.poolside:
+        case tokenType.velodrome:
+        case tokenType.aerodrome:
+        case tokenType.dragonswap:
+        case tokenType.akron:
+        case tokenType.koi:
+        case tokenType.baseswap:
+        case tokenType.fenix:
+        case tokenType.zkswap:
+        case tokenType.ra:
+        case tokenType.syncswap:
+        case tokenType.pancakeswap:
+        case tokenType.traderJoe:
+        case tokenType.katana:
+            return `Provide liquidity to ${typeInfo.protocol} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
+        case tokenType.pendleYT:
+            return `Hold ${typeInfo.protocol} ${typeInfo.name}`;
+        case tokenType.pendle:
+            return `Provide ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.balancerGauge:
+            return `${typeInfo.protocol} ${symbols.join("-")}`;
+        case tokenType.beraborrow_gauge:
+        case tokenType.beratrax_vault:
+            return `Deposit ${symbols.join("-")} on ${typeInfo.protocol}`;
+        case tokenType.balancerPool: {
+            if (campaign.computeChainId === ChainId.SONIC) {
+                typeInfo.protocol = "Beets";
+            }
+            let cardName = `Provide liquidity to ${typeInfo.protocol} ${symbols.join("-")}`;
+            if (typeInfo.vault === "0xFB43069f6d0473B85686a85F4Ce4Fc1FD8F00875") {
+                cardName = `Provide liquidity to Jellyverse Pool ${symbols.join("-")}`;
+            }
+            return cardName;
+        }
+        case tokenType.balancerV3: {
+            if (campaign.computeChainId === ChainId.SONIC) {
+                typeInfo.protocol = "Beets";
+            }
+            return `Provide liquidity to ${typeInfo.protocol} Boosted ${symbols.join("-")}`;
+        }
+        case tokenType.aura:
+            return `Provide liquidity to ${typeInfo.protocol} ${symbols.join("-")}`;
+        case tokenType.gearbox:
+            return `${typeInfo.protocol} ${typeInfo.symbolUnderlyingToken} Deposit`;
+        case tokenType.compound:
+            return `Lend ${typeInfo.symbolBaseToken} on ${typeInfo.protocol}`;
+        case tokenType.radiant_lend: {
+            let cardToken = typeInfo.symbolUnderlyingToken;
+            if (campaign.campaignParameters.symbolTargetToken.startsWith("r")) {
+                cardToken = campaign.campaignParameters.symbolTargetToken.substring(1);
+            }
+            return `Lend ${cardToken} on ${typeInfo.protocol}`;
+        }
+        case tokenType.rfx:
+            return `Supply ${typeInfo.symbolShortToken}-${typeInfo.symbolLongToken} on ${typeInfo.protocol}`;
+        case tokenType.radiant_borrow:
+        case tokenType.aave_borrowing:
+        case tokenType.vicuna_borrowing:
+        case tokenType.yei_borrowing:
+        case tokenType.ironclad_borrowing:
+        case tokenType.zerolend_borrowing:
+        case tokenType.avalon_borrowing:
+        case tokenType.superlend_borrowing:
+        case tokenType.takotako_borrowing:
+        case tokenType.lendle_borrowing:
+        case tokenType.euler_borrow:
+            return `Borrow ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.ionic:
+        case tokenType.layerbank:
+        case tokenType.moonwell:
+        case tokenType.splice:
+        case tokenType.aave_lending:
+        case tokenType.vicuna_lending:
+        case tokenType.yei_lending:
+        case tokenType.ironclad_lending:
+        case tokenType.zerolend_lending:
+        case tokenType.avalon_lending:
+        case tokenType.takotako_lending:
+        case tokenType.superlend_lending:
+        case tokenType.lendle_lending:
+        case tokenType.fraxlend:
+        case tokenType.venus:
+        case tokenType.reactor_fusion:
+        case tokenType.euler_lend:
+            return `Supply ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.metamorpho:
+            return `Supply to ${typeInfo.name} on ${typeInfo.protocol}`;
+        case tokenType.sturdy_aggregator:
+            return `Supply ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol} ${typeInfo.name}`;
+        case tokenType.sturdy_silo:
+            return `Supply ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol} ${typeInfo.symbolCollateral} Silo`;
+        case tokenType.curve:
+        case tokenType.curve_2:
+            return `Provide liquidity to ${typeInfo.protocol} ${Object.values(typeInfo.poolTokens).join("-")}`;
+        case tokenType.fluid:
+            return `Lend ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.enzyme:
+            return `Supply to the ${typeInfo.name} on ${typeInfo.protocol}`;
+        case tokenType.filament:
+            return `Earn Yield on ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.silostaking:
+            return `Stake ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.beefy:
+            return `Provide liquidity to ${typeInfo.protocol} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
+        case tokenType.toros:
+            return `${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken}) on ${typeInfo.protocol}`;
+        case tokenType.ironcladStaking:
+            return `Stake ${campaign.campaignParameters.symbolTargetToken} on ${typeInfo.protocol}`;
+        case tokenType.woofi:
+            return `Supercharge ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.maverickBoostedPosition:
+            return `Maverick Boosted Position ${campaign.campaignParameters.symbolTargetToken}`;
+        case tokenType.zkSwapThreePool:
+            return `Provide liquidity to ${typeInfo.protocol} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}-${typeInfo.symbolToken2}`;
+        case tokenType.maha:
+            return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} LP on ${typeInfo.protocol}`;
+        case tokenType.tempest:
+        case tokenType.tempestStaking:
+            return `Deposit into ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} vault on ${typeInfo.protocol}`;
+        case tokenType.holdstation:
+            return `Hold vault token ${campaign.campaignParameters.symbolTargetToken} on ${typeInfo.protocol}`;
+        case tokenType.cpmmGamma:
+            return `Provide ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} on ${typeInfo.protocol}`;
+        case tokenType.crosscurve:
+            if (typeInfo.name.toLowerCase() === "eywa/usdt") {
+                return `Curve ${typeInfo.name}`;
+            }
+            return `${typeInfo.name}`;
+        case tokenType.curveNPool:
+            return `Curve ${typeInfo.name}`;
+        case tokenType.vicuna: {
+            const parsedName = typeInfo.name.split(" ");
+            parsedName.shift();
+            const parsedNameForCard = parsedName.join(" ");
+            return `Deposit liquidity on ${parsedNameForCard.replace("BALANCER", "Beets")} vault on Vicuna`;
+        }
+        case tokenType.satlayer:
+            return `Restake ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.veda:
+            return `Deposit into ${typeInfo.name.replace("Ether.Fi", "Veda")}`;
+        case tokenType.concrete:
+        case tokenType.cian:
+            return `Deposit ${typeInfo.symbolAsset} into ${typeInfo.name.replace("Ether.Fi", "Veda")}`;
+        case tokenType.rfx_slv:
+            return `Deposit ${typeInfo.symbolAsset} into ${typeInfo.name}`;
+        case tokenType.equalizer_gauge:
+            return `${displayName}`;
+        case tokenType.anglesLiquid:
+            return `Deposit into ${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken}) Vault`;
+        case tokenType.spectra_lpt:
+            return `Provide liquidity on Spectra to ${typeInfo.name}`;
+        case tokenType.spectra_yt:
+            return `Hold Spectra ${typeInfo.name}`;
+        case tokenType.hourglass:
+            return `Deposit ${typeInfo.symbolUnderlyingToken} into Hourglass`;
+        case tokenType.hanji_liquidity_vault_token:
+            return "Provide Liquidity on Hanji Vault";
+        case tokenType.bunniV2:
+            return `Provide Liquidity on Bunni V2 ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
+        default:
+            // OVERRIDE
+            switch (typeInfo.tokenAddress) {
+                case "0x3a8099D8FE5C072bB035381003993393072D3ec7":
+                    return "Hold pufETH on DeSyn (dpufETH)";
+                case "0x1f2aa9680910aC5a4527FA72001dC249943f60b4":
+                    return "Hold pufETH on Karak";
+                default:
+                    return `Hold ${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken})`;
+            }
+    }
+}

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

@@ -0,0 +1,3 @@
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import type { Campaign, CampaignParameters } from "@sdk";
+export declare function generateIcons(type: tokenType, typeInfo: any, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, symbols?: string[]): string[];

package/dist/src/utils/generateIcons.js

@@ -0,0 +1,65 @@
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { OpportunityAction } from "@db/api";
+export function generateIcons(type, typeInfo, campaign, symbols = [""]) {
+    const action = typeInfo.action ? typeInfo.action : "HOLD";
+    switch (action) {
+        case OpportunityAction.POOL:
+            switch (type) {
+                case tokenType.vicuna: {
+                    const parsedName = typeInfo.name.split(" ").pop();
+                    return parsedName.split("-");
+                }
+                case tokenType.balancerGauge:
+                case tokenType.balancerPool:
+                case tokenType.aura:
+                    return Object.values(typeInfo.poolTokens ?? {})
+                        .map(tkn => tkn?.symbol)
+                        .filter(tkn => tkn && !tkn.includes("/"));
+                case tokenType.curve:
+                case tokenType.curve_2:
+                case tokenType.hanji_liquidity_vault_token:
+                case tokenType.crosscurve: {
+                    const icons = [];
+                    for (let i = 0; i < typeInfo.numberTokens; i++) {
+                        if (typeInfo[`symbolToken${i}`])
+                            icons.push(typeInfo[`symbolToken${i}`]);
+                    }
+                    return icons;
+                }
+                case tokenType.rfx_slv:
+                    return [typeInfo.symbolAsset];
+                case tokenType.rfx:
+                    return [typeInfo.symbolShortToken, typeInfo.symbolLongToken];
+                case tokenType.maverickBoostedPosition:
+                    return [typeInfo.symbolTokenA, typeInfo.symbolTokenB];
+                default:
+                    return [typeInfo.symbolToken0, typeInfo.symbolToken1];
+            }
+        case OpportunityAction.LEND:
+            switch (type) {
+                case tokenType.compound:
+                    return [typeInfo.symbolBaseToken];
+                default:
+                    return [typeInfo.symbolUnderlyingToken];
+            }
+        case OpportunityAction.BORROW:
+            return [typeInfo.symbolUnderlyingToken];
+        case OpportunityAction.HOLD:
+            switch (type) {
+                case tokenType.toros:
+                case tokenType.enzyme:
+                    return [typeInfo.symbolUnderlyingToken];
+                case tokenType.pendleYT: {
+                    let symbol = campaign.campaignParameters.symbolTargetToken;
+                    symbol = symbol.split("-").slice(0, 2).join("-");
+                    return [symbol];
+                }
+                case tokenType.pendle:
+                    return [typeInfo.symbolUnderlyingToken];
+                default:
+                    return [campaign.campaignParameters.symbolTargetToken];
+            }
+        default:
+            return [];
+    }
+}

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

@@ -0,0 +1,7 @@
+import { type MerklChainId } from "@sdk";
+import { type BigNumberish } from "ethers";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+export declare function batchMulticallCallWithRetry(chainId: MerklChainId, args: {
+    calls: Multicall3.Call3Struct[];
+    blockNumber?: BigNumberish;
+}): Promise<Multicall3.ResultStructOutput[]>;

package/dist/src/utils/generic.js

@@ -0,0 +1,43 @@
+import { withRetry } from "@sdk";
+import { BigNumber } from "ethers";
+import { MAX_NUM_SUBCALLS } from "../constants";
+import { multicalls } from "./providers";
+async function archiveContractMethodCall(contract, args) {
+    return contract.interface.decodeFunctionResult("aggregate3", !!args.blockNumber
+        ? await contract.provider.call({
+            data: contract.interface.encodeFunctionData("aggregate3", [args.calls]),
+            to: contract.address,
+        }, BigNumber.from(args.blockNumber).toNumber())
+        : await contract.provider.call({
+            data: contract.interface.encodeFunctionData("aggregate3", [args.calls]),
+            to: contract.address,
+        }))[0];
+}
+export async function batchMulticallCallWithRetry(chainId, args) {
+    let fetchedData = [];
+    let remainingCalls = args.calls.length;
+    let lowerIdx = 0;
+    let upperIdx = Math.min(args.calls.length, MAX_NUM_SUBCALLS);
+    const multicallBatch = [];
+    while (remainingCalls !== 0) {
+        multicallBatch.push(await withRetry(archiveContractMethodCall, [
+            multicalls[chainId],
+            {
+                blockNumber: args.blockNumber,
+                calls: args.calls.slice(lowerIdx, upperIdx),
+            },
+        ]));
+        remainingCalls -= upperIdx - lowerIdx;
+        lowerIdx = upperIdx;
+        upperIdx = Math.min(args.calls.length, upperIdx + MAX_NUM_SUBCALLS);
+    }
+    /** Executing batched multicall */
+    const results = await Promise.allSettled(multicallBatch);
+    for (let k = 0; k < results.length; k++) {
+        const res = results[k];
+        if (res.status === "fulfilled") {
+            fetchedData = fetchedData.concat(res.value);
+        }
+    }
+    return fetchedData;
+}

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

@@ -0,0 +1,2 @@
+export declare function sha256(x: string): string;
+export declare function hashArray(...args: any[]): string;

package/dist/src/utils/hashArray.js

@@ -0,0 +1,7 @@
+import crypto from "node:crypto";
+export function sha256(x) {
+    return crypto.createHash("sha256").update(x).digest("hex");
+}
+export function hashArray(...args) {
+    return args.length > 0 ? sha256(JSON.stringify(args.map(a => a.toString()))) : "";
+}

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

@@ -0,0 +1,3 @@
+import type { MerklChainId } from "@sdk";
+export declare const getBlockTimestamp: (provider: any, blockNumber: number) => Promise<number>;
+export declare const getLastBlockBeforeWithCache: (timestamp: number, chainId: MerklChainId) => Promise<any>;

package/dist/src/utils/lastBlockBefore.js

@@ -0,0 +1,78 @@
+import { Redis } from "@/cache";
+import { hashArray } from "@/utils/hashArray";
+import { BigNumber } from "ethers";
+import moment from "moment";
+import { log } from "./logger";
+import { providers } from "./providers";
+/**
+ * Fetches the timestamp of a block with up to RETRIES retries in case of failure
+ */
+const RETRIES = 10;
+export const getBlockTimestamp = async (provider, blockNumber) => {
+    let res = null;
+    let trial = 0;
+    while (res === null && trial < RETRIES) {
+        try {
+            res = await provider.send("eth_getBlockByNumber", [`0x${blockNumber.toString(16)}`, false]);
+        }
+        catch { }
+        trial++;
+    }
+    if (trial > 1) {
+        console.log(`${trial - 1} calls failed fetching blocktimestamp for block ${blockNumber}.`);
+    }
+    return BigNumber.from(res?.timestamp).toNumber();
+};
+/**
+ * Binary search to search the last block before a given timestamp
+ */
+const getLastBlockBefore = async (timestamp, chainId) => {
+    if (moment().unix() < timestamp) {
+        log.error("getLastBlockBefore", `Timestamp ${timestamp} is in the future`);
+        return 0;
+    }
+    const provider = providers[chainId];
+    const current = await provider.getBlockNumber();
+    let upper = current;
+    let lower = 0;
+    let step = Math.floor((upper - lower) / 2);
+    let fixUpper = false;
+    let fixLower = false;
+    while (upper - lower > 1) {
+        // Reduce step size of interval has been found
+        if (upper - lower < 2 * step) {
+            step = Math.floor(step / 2);
+            fixUpper = false;
+            fixLower = false;
+        }
+        // Check reduction of upper bound
+        if (!fixUpper) {
+            const auxUpper = upper - step;
+            const auxUpperTimestamp = await getBlockTimestamp(provider, auxUpper);
+            if (auxUpperTimestamp > timestamp) {
+                upper = auxUpper;
+            }
+            else {
+                fixUpper = true;
+            }
+        }
+        // Check reduction of lower bound
+        if (!fixLower) {
+            const auxLower = lower + step;
+            const auxLowerTimestamp = await getBlockTimestamp(provider, auxLower);
+            if (auxLowerTimestamp <= timestamp) {
+                lower = auxLower;
+            }
+            else {
+                // auxLower timestamp >= timestamp
+                // We want to return the last block with a timestamp <= timestamp
+                fixLower = true;
+                if (auxLowerTimestamp === timestamp) {
+                    return auxLower;
+                }
+            }
+        }
+    }
+    return lower;
+};
+export const getLastBlockBeforeWithCache = async (timestamp, chainId) => await Redis.getOrSet(`LastBlockBefore_${hashArray([timestamp, chainId])}`, getLastBlockBefore, timestamp, chainId);

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

@@ -0,0 +1,62 @@
+export declare const logger: import("@bogeychan/elysia-logger/types").ElysiaLogger<import("elysia").default<"", {
+    decorator: {};
+    store: {};
+    derive: {
+        readonly log: import("pino").default.Logger<never, boolean>;
+    };
+    resolve: {};
+}, {
+    typebox: import("@sinclair/typebox").TModule<{}>;
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}> | import("elysia").default<"", {
+    decorator: {};
+    store: import("@bogeychan/elysia-logger/types")._INTERNAL_Writeonly<import("@bogeychan/elysia-logger/types")._INTERNAL_ElysiaLoggerPluginAutoLoggingState>;
+    derive: {
+        readonly log: import("@bogeychan/elysia-logger/types").Logger;
+    };
+    resolve: {};
+}, {
+    typebox: import("@sinclair/typebox").TModule<{}>;
+    error: {};
+}, {
+    schema: import("elysia").MergeSchema<import("elysia").MergeSchema<{}, {}, "">, {}, "">;
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>>;
+export declare const log: {
+    debug: (message: string) => void;
+    error: (message: string, errorMessage: any, service?: string, url?: string) => void;
+    info: (message: string) => void;
+    local: (message: string) => void;
+    warn: (message: string) => void;
+};

package/dist/src/utils/logger.js

@@ -0,0 +1,52 @@
+import { createPinoLogger } from "@bogeychan/elysia-logger";
+export const logger = createPinoLogger({
+    base: undefined,
+    formatters: {
+        level(level) {
+            return { level };
+        },
+    },
+    level: process.env.LOG_LEVEL || "info",
+    name: process.env.APP_NAME || "api",
+    transport: process.env.ENV !== "local"
+        ? undefined
+        : {
+            options: {
+                colorize: true,
+                ignore: "time,name,hostname,pid,baseUrl,fullUrl,requestId,chain",
+                messageFormat: "\u001b[35m{baseUrl}\u001b[39m \u001b[33m{chain}\u001b[39m {msg}",
+            },
+            target: "pino-pretty",
+        },
+});
+const logConstructor = (type, message, errorMessage, onlyDev, service, url) => {
+    if (onlyDev && process.env.ENV !== "local")
+        return;
+    if (type === "error") {
+        if (!!service && !!url) {
+            logger.child({ service, url }).error(errorMessage, message);
+        }
+        else if (!!service) {
+            logger.child({ service }).error(errorMessage, message);
+        }
+        else {
+            logger.error(errorMessage, message);
+        }
+    }
+    else if (type === "warn") {
+        logger.warn(message);
+    }
+    else if (type === "debug") {
+        logger.debug(message);
+    }
+    else {
+        logger.info(message);
+    }
+};
+export const log = {
+    debug: (message) => logConstructor("debug", message),
+    error: (message, errorMessage, service, url) => logConstructor("error", message, errorMessage, false, service, url),
+    info: (message) => logConstructor("info", message),
+    local: (message) => logConstructor("info", message, undefined, true),
+    warn: (message) => logConstructor("warn", message),
+};