@merkl/api 0.10.129 → 0.10.130

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

@@ -0,0 +1,160 @@
+import { Redis } from "../../cache";
+import { campaignsToOldFormat } from "../../libs/deprecated-merklv3";
+import { AprService, CampaignService, OpportunityService } from "../../modules/v4";
+import { CacheService } from "../../modules/v4/cache";
+import { TTLPresets } from "../../modules/v4/cache/cache.model";
+import { OpportunityRepository } from "../../modules/v4/opportunity/opportunity.repository";
+import { RewardService } from "../../modules/v4/reward";
+import { TvlService } from "../../modules/v4/tvl";
+import { engineDbClient } from "../../utils/prisma";
+import { Campaign, ChainId, NETWORK_LABELS, isSupportedChain, } from "@sdk";
+import { Elysia, t } from "elysia";
+import moment from "moment";
+import { campaignsDynamicData } from "../../libs/campaigns/campaignsDynamicData";
+import { merklChainData } from "../../libs/merklChainData";
+import { staticCampaignWithCache } from "../../libs/staticCampaigns";
+import { InvalidParameter, UnsupportedNetwork } from "../../utils/error";
+import { executeSimple } from "../../utils/execute";
+import { log } from "../../utils/logger";
+import { ALL_CAMPAIGNS_FOR_CHAIN_AFTER } from "../../utils/queries/allCampaigns";
+const highCampaignsChains = [ChainId.ARBITRUM, ChainId.POLYGON, ChainId.BLAST, ChainId.BASE];
+export const campaignsCacheUpdater = new Elysia().get("/v3/update", async ({ query, set }) => {
+    const rawChainId = query.chainId;
+    let chainId;
+    if (typeof rawChainId === "string") {
+        chainId = Number.parseInt(rawChainId);
+        if (!isSupportedChain(chainId, "merkl"))
+            throw new UnsupportedNetwork(chainId);
+    }
+    else {
+        throw new InvalidParameter("Invalid chainId provided");
+    }
+    let success = true;
+    try {
+        await Redis.safeSet(`MerklChainData_${chainId}`, await merklChainData(chainId));
+    }
+    catch (error) {
+        log.error(`❌ update merklChainData cache failed for ${NETWORK_LABELS[chainId]}`, error);
+        success = false;
+    }
+    log.local(`🔁 updating ${NETWORK_LABELS[chainId]} Campaigns cache`);
+    let campaignsAfter = moment().subtract(3, "months").unix();
+    if (highCampaignsChains.includes(chainId)) {
+        campaignsAfter = moment().subtract(1, "months").unix();
+    }
+    const TWO_WEEKS_AGO = moment().subtract(2, "weeks").unix();
+    try {
+        const dynamicData = {};
+        let staticData = (await engineDbClient.$queryRaw(ALL_CAMPAIGNS_FOR_CHAIN_AFTER(chainId, campaignsAfter)));
+        log.local(`Data length before filtering: ${staticData.length}`);
+        const mainParameters = {};
+        staticData = staticData.filter(campaign => {
+            if (campaign.endTimestamp < TWO_WEEKS_AGO && campaign.campaignType === Campaign.CLAMM) {
+                campaign.campaignParameters.forwarders = [];
+            }
+            mainParameters[campaign.mainParameter] = true;
+            return true;
+        });
+        log.local(`Data length after filtering: ${staticData.length}`);
+        if (!!staticData) {
+            // Build list of existing campaign types for this chain
+            const campaignTypes = !staticData
+                ? []
+                : staticData
+                    .map(campaign => campaign.campaignType)
+                    .reduce((prev, campaignType) => {
+                    if (!prev.includes(campaignType))
+                        prev.push(campaignType);
+                    return prev;
+                }, []);
+            // Fetch dynamic data for all these types
+            const promisesPerType = campaignTypes.map(async (campaignType) => {
+                const campaigns = staticData.filter(campaign => campaign.campaignType === campaignType);
+                await executeSimple(chainId, campaignsDynamicData(chainId, campaigns, campaignType)).then(r => {
+                    for (const d of r) {
+                        if (!!d) {
+                            // Main Parameter OVERRIDING
+                            if (d.campaignType === Campaign.SILO && d.campaignParameters.whitelist?.length === 1) {
+                                d.mainParameter = `${d.mainParameter}-${d.campaignParameters.whitelist[0]}`;
+                            }
+                            if (!dynamicData[`${d.campaignType}_${d.mainParameter}`])
+                                dynamicData[`${d.campaignType}_${d.mainParameter}`] = {};
+                            dynamicData[`${d.campaignType}_${d.mainParameter}`][d.campaignId] = d;
+                        }
+                    }
+                });
+            });
+            await Promise.all(promisesPerType);
+        }
+        if (!!dynamicData && Object.keys(dynamicData).length > 0) {
+            await Redis.safeSet(`Campaigns_${chainId}`, dynamicData);
+            // Set live or future campaigns
+            const liveDynamicData = {};
+            for (const [type_mainParameter, value] of Object.entries(dynamicData)) {
+                for (const [campaignId, data] of Object.entries(value)) {
+                    if (data.endTimestamp > moment().unix()) {
+                        if (!liveDynamicData[type_mainParameter]) {
+                            liveDynamicData[type_mainParameter] = {};
+                        }
+                        liveDynamicData[type_mainParameter][campaignId] = data;
+                    }
+                }
+            }
+            await Redis.safeSet(`LiveCampaigns_${chainId}`, liveDynamicData);
+            const merklChainData = await Redis.get("MerklChainData", chainId);
+            await Redis.safeSet(`CampaignsOldFormat_${chainId}`, campaignsToOldFormat(dynamicData, merklChainData));
+            await Redis.safeSet(`LiveCampaignsOldFormat_${chainId}`, campaignsToOldFormat(liveDynamicData, merklChainData));
+            log.info(`✅ ${NETWORK_LABELS[chainId]} caches updated successfully`);
+            for (const entry of Object.entries(liveDynamicData)) {
+                await CampaignService.fill(Object.values(entry[1]).map(({ campaignId, chainId }) => ({
+                    campaignId,
+                    distributionChain: chainId,
+                })));
+                const [type, mainParameter] = entry[0].split("_");
+                const apr = AprService.extractFromDynamicData(+type, Object.values(entry[1]));
+                const tvl = TvlService.extractFromDynamicData(+type, Object.values(entry[1]));
+                const dailyRewards = await RewardService.extractDailyRewardsRecordFromDynamicData(+type, Object.values(entry[1]));
+                const opportunityId = OpportunityService.hashId({
+                    chainId,
+                    identifier: mainParameter,
+                    type: CampaignService.getTypeFromV3(+type),
+                });
+                await OpportunityRepository.updateRecords(opportunityId, apr, tvl, dailyRewards);
+            }
+            await OpportunityService.updateMetadata(chainId);
+            // ─── Refresh Cache For GET /opportunities ────
+            await CacheService.set(TTLPresets.MIN_5, OpportunityService.getMany, { items: 50, page: 0 });
+            log.info(`✅ ${NETWORK_LABELS[chainId]} DB records updated successfully`);
+        }
+        else {
+            if (chainId === ChainId.CORE || chainId === ChainId.THUNDERCORE) {
+                log.info(`⚠️ no campaigns found for ${NETWORK_LABELS[chainId]}, setting empty cache`);
+                for (const key of [
+                    "Campaigns",
+                    "LiveCampaigns",
+                    "CampaignsOldFormat",
+                    "LiveCampaignsOldFormat",
+                ]) {
+                    await Redis.safeSet(`${key}_${chainId}`, {});
+                }
+                log.info(`✅ ${NETWORK_LABELS[chainId]} caches updated - empty cache`);
+            }
+        }
+    }
+    catch (error) {
+        log.error(`❌ update Campaigns cache failed for ${NETWORK_LABELS[chainId]}`, error);
+        success = false;
+    }
+    // This is independant of campaigns cache update, so not in the if condition
+    try {
+        await staticCampaignWithCache(chainId);
+    }
+    catch (error) {
+        log.error(`❌ update Campaigns cache failed for ${NETWORK_LABELS[chainId]}`, error);
+    }
+    return { success };
+}, {
+    query: t.Object({
+        chainId: t.String(),
+    }),
+});

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

@@ -0,0 +1,15 @@
+import { Redis } from "../../cache";
+import { t } from "elysia";
+export const response = t.Object({ success: t.Boolean() });
+export const healthCheck = (app) => {
+    return app.get("/v3/health", async () => {
+        // Check if the cache is working
+        await Redis.get("Prices");
+        return {
+            success: true,
+        };
+    }, {
+        query: t.Object({}),
+        tags: ["Onchain"],
+    });
+};

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

@@ -0,0 +1,63 @@
+import { Redis } from "../../cache";
+import { ANGLE_NETWORKS } from "@sdk";
+import { extractIds, getCampaignsFor, splitCampaigns } from "../../entities/campaign";
+import { extractOpportunities } from "../../entities/opportunity";
+import { log } from "../../utils/logger";
+import { Pricer } from "../../utils/pricer";
+export const OPPORTUNITY_CACHE = "Opportunities_All";
+export const OPPORTUNITY_CACHE_TEST = "Opportunities_Test";
+const reduceOpportunities = async (showTest = false) => {
+    const campaigns = await getCampaignsFor(ANGLE_NETWORKS.merkl.map(c => c));
+    const pricer = await Pricer.load();
+    const opportunityIds = extractIds(campaigns);
+    const opportunityCampaigns = splitCampaigns(campaigns, opportunityIds, showTest);
+    const opportunities = {};
+    for (const { id, ...opportunity } of opportunityCampaigns) {
+        const [_, type, mainParameter] = id.split("_");
+        if (!extractOpportunities[type])
+            continue;
+        const { campaigns: oppCampaigns, ...extracted } = extractOpportunities[type](opportunity?.all?.[0], {
+            all: opportunity?.all ?? [],
+            active: opportunity.active ?? [],
+            inactive: opportunity.inactive ?? [],
+        }, pricer?.prices);
+        opportunities[`${type}_${mainParameter}`] = {
+            ...extracted,
+            campaigns: {
+                type: Number.parseInt(type),
+                ids: opportunity?.all?.map(({ campaignId }) => campaignId).filter(c => c),
+            },
+        };
+    }
+    return opportunities;
+};
+const getUpdateBreakdown = (opportunities) => {
+    const total = Object.keys(opportunities)?.length;
+    const totalByChain = Object.entries(opportunities).reduce((prev, [_, { chainId }]) => {
+        prev[chainId] += 1;
+        return prev;
+    }, ANGLE_NETWORKS.merkl.reduce((allChains, chain) => Object.assign(allChains, { [chain]: 0 }), {}));
+    const breakdown = Object.entries(totalByChain).reduce((prev, [chain, count]) => {
+        if (count === 0)
+            return prev;
+        prev[chain] = count;
+        return prev;
+    }, {});
+    return { total, breakdown };
+};
+export const opportunityUpdater = (app) => {
+    return app.get("/v3/updateOpportunities", async () => {
+        const opportunities = await reduceOpportunities(false);
+        const opportunitiesWithTest = await reduceOpportunities(true);
+        await Redis.safeSet("Opportunities", opportunities);
+        await Redis.safeSet("OpportunitiesWithTest", opportunitiesWithTest);
+        log.info("✅ opportunity cache updated successfully");
+        return new Response(JSON.stringify({
+            status: "success",
+            all: getUpdateBreakdown(opportunities),
+            test: getUpdateBreakdown(opportunitiesWithTest),
+        }), {
+            status: 200,
+        });
+    });
+};

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

@@ -0,0 +1,16 @@
+import { TokenService } from "../../modules/v4";
+import { log } from "../../utils/logger";
+import { Pricer } from "../../utils/pricer";
+export const priceUpdater = (app) => {
+    return app.get("/v3/updatePrices", async () => {
+        const pricer = await Pricer.load();
+        await pricer.update();
+        log.info("✅ price cache updated successfully");
+        await TokenService.updatePrices(pricer);
+        return new Response(JSON.stringify({
+            status: "success",
+        }), {
+            status: 200,
+        });
+    });
+};

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

@@ -0,0 +1,33 @@
+import { AuthorizationHeadersDto, EngineGuard } from "../../guards/Engine.guard";
+import { CampaignService } from "../../modules/v4/campaign";
+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({});
+    for (const chain of chains) {
+        log.info(`fetching campaigns on ${chain.name} (chainId: ${chain.id})`);
+        const campaignsV3 = await CampaignService.getFromEngineDb(chain.id, 0);
+        const campaigns = campaignsV3.map(campaignV3 => {
+            return {
+                amount: campaignV3.amount,
+                campaignId: campaignV3.campaignId,
+                chainId: campaignV3.chainId,
+                computeChainId: campaignV3.computeChainId,
+                creator: campaignV3.creator,
+                endTimestamp: campaignV3.endTimestamp.toString(),
+                opportunityIdentifier: campaignV3.mainParameter,
+                params: JSON.stringify(campaignV3.campaignParameters),
+                rewardTokenAddress: campaignV3.rewardToken,
+                startTimestamp: campaignV3.startTimestamp.toString(),
+                type: campaignV3.campaignType,
+                subType: campaignV3.campaignSubType,
+            };
+        });
+        log.info(`syncing ${campaigns.length} campaigns to sync on ${chain.name}...`);
+        const { success, fail } = await CampaignService.createMany(campaigns);
+        log.info(`${success} campaigns synced successfully on ${chain.name}`);
+        log.info(`${fail} campaigns failed to sync on ${chain.name}`);
+    }
+    return;
+}, { headers: AuthorizationHeadersDto, beforeHandle: EngineGuard });

package/dist/src/cache/declaration.js

@@ -0,0 +1,146 @@
+import { TTLType } from "./redis";
+export const CacheDeclaration = {
+    Updates: { compressed: false, redisTTL: TTLType.Minutes2, localCache: false },
+    Delays: { compressed: false, redisTTL: TTLType.Minutes2, localCache: false },
+    TwtParticipants: { compressed: false, redisTTL: TTLType.Minutes5, localCache: false },
+    CampaignRewards: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    RewardsMainParameter: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    RewardsMainParameterDelta: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    CampaignRewardsDelta: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    LastBlockBefore: {
+        compressed: false,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    LostYield: {
+        compressed: false,
+        redisTTL: TTLType.Hours3,
+        localCache: false,
+    },
+    DolomiteMarkets: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    EulerV2Vaults: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    CompoundV2ForksVaults: {
+        compressed: false,
+        redisTTL: TTLType.Week,
+        localCache: false,
+    },
+    RadiantMarkets: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    SiloMarkets: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    MorphoMarkets: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    FarmedPositions: {
+        compressed: false,
+        redisTTL: TTLType.Minutes2,
+        localCache: false,
+    },
+    JsonByTimestamp: {
+        compressed: false,
+        redisTTL: TTLType.Minutes10,
+        localCache: false,
+    },
+    Prices: {
+        compressed: true,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    MerklChainData: {
+        compressed: false,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    Opportunities: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    OpportunitiesWithTest: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    Campaigns: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    LiveCampaigns: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    CampaignsOldFormat: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    LiveCampaignsOldFormat: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    StaticCampaigns: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    Blacklist: {
+        compressed: true,
+        redisTTL: TTLType.Minutes10,
+        localCache: false,
+    },
+    TokenList: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    CurrentRoot: {
+        compressed: false,
+        redisTTL: TTLType.Seconds30,
+        localCache: true,
+    },
+    Chains: {
+        compressed: false,
+        redisTTL: TTLType.Hours3,
+        localCache: true,
+    },
+    RootsWithRewardOnChain: {
+        compressed: false,
+        redisTTL: TTLType.Minutes2,
+        localCache: true,
+    },
+};

package/dist/src/cache/index.js

@@ -0,0 +1,152 @@
+import { InvalidCacheCall } from "../utils/error";
+import { log } from "../utils/logger";
+import { withRetry, withTimeout } from "@sdk";
+import NodeCache from "node-cache";
+import { CacheDeclaration } from "./declaration";
+import { REDIS_CRON_WRITE_TIMEOUT, REDIS_READ_TIMEOUT, REDIS_RETRIES, redisClient } from "./redis";
+export class Cache {
+    static decoder = new TextDecoder();
+    static encoder = new TextEncoder();
+    localCache = new NodeCache();
+    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                                         UTILS
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+    static baseKey(key) {
+        return key.split("_")[0];
+    }
+    /** @notice Uncompress (if enabled), parsed and typed data from the cache */
+    static uncompress(key, value) {
+        const { compressed } = CacheDeclaration[Cache.baseKey(key)];
+        if (!compressed)
+            return JSON.parse(value);
+        if (!value)
+            return {};
+        const encoded = Buffer.from(value, "base64");
+        const uncompressed = Bun.gunzipSync(encoded);
+        const decoded = Cache.decoder.decode(uncompressed);
+        return JSON.parse(decoded);
+    }
+    /** @notice Compress (if enabled), stringify and encoded data to be stored in the cache */
+    static compress(key, value) {
+        const { compressed } = CacheDeclaration[Cache.baseKey(key)];
+        if (!compressed)
+            return JSON.stringify(value);
+        const encoded = Cache.encoder.encode(JSON.stringify(value));
+        const compressedValue = Bun.gzipSync(encoded);
+        return Buffer.from(compressedValue).toString("base64");
+    }
+    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                                      REDIS CACHE
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+    async getRaw(key) {
+        if (!key || key === "")
+            throw new InvalidCacheCall("Trying to access cache with no key");
+        return await withRetry(withTimeout, [redisClient.get(key), REDIS_READ_TIMEOUT], REDIS_RETRIES);
+    }
+    async getManyRaw(keys) {
+        if (keys?.length === 0)
+            throw new InvalidCacheCall("Trying to access cache with no keys");
+        const strippedKeys = Array.from(keys.map(a => a.split("_")[0]).reduce((unique, key) => unique.add(key), new Set()));
+        const multipleCached = await withRetry(withTimeout, [redisClient.mGet(keys), REDIS_READ_TIMEOUT], REDIS_RETRIES);
+        log.local(`Redis: ${keys.length} data fetched with mGet`);
+        return multipleCached;
+    }
+    async setRaw(key, value) {
+        const { redisTTL } = CacheDeclaration[Cache.baseKey(key)];
+        await redisClient.set(key, value, { EX: redisTTL });
+    }
+    /** @notice Set value for a given key for both local and raw cache */
+    async set(key, value) {
+        this.setLocally(key, value);
+        this.setRaw(key, Cache.compress(key, value));
+    }
+    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                                      LOCAL CACHE
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+    isLocallyCached(key) {
+        return false;
+        // return this.localCache.has(key);
+    }
+    setLocally(key, value) {
+        return true;
+        // const { localCacheTtl } = CacheDeclaration[Cache.baseKey<T, Key>(key)] as { localCacheTtl?: number };
+        // return this.localCache.set(key, value, localCacheTtl ?? DEFAULT_LOCAL_TTL);
+    }
+    getLocally(key) {
+        return undefined;
+        // return this.localCache.get(key);
+    }
+    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                                   PUBLIC OPERATIONS
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+    /**
+     * @returns the uncompressed (if enabled), parsed and typed data from the cache
+     */
+    async get(key, args) {
+        const actualKey = (args ? `${key}_${args}` : key);
+        if (this.isLocallyCached(actualKey))
+            return this.getLocally(actualKey);
+        const rawCache = await this.getRaw(actualKey);
+        if (rawCache === null)
+            return null;
+        const value = Cache.uncompress(actualKey, rawCache);
+        this.setLocally(actualKey, value);
+        return value;
+    }
+    /**
+     * Get many data from cache
+     * @param key cache key
+     * @returns the uncompressed (if enabled), parsed and typed data from the cache for all keys
+     */
+    async getMany(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 => {
+            if (!nonLocalKeys.includes(key))
+                return this.localCache.get(key);
+            const cachedValue = cached[nonLocalKeys.indexOf(key)];
+            if (cachedValue !== null) {
+                const value = Cache.uncompress(key, cachedValue);
+                this.setLocally(key, value);
+                return value;
+            }
+            return null;
+        });
+        return res;
+    }
+    /**
+     * Get many data from cache with argument
+     * @param key cache key
+     * @param args arguments to append to cache keys
+     * @returns the uncompressed (if enabled), parsed and typed data from the cache for all keys
+     */
+    async getManyWithArgs(key, args) {
+        const actualKeys = args.map(arg => `${key}_${arg}`);
+        return this.getMany(actualKeys);
+    }
+    /**
+     * Get data from cache or set it using the callback
+     * @param key cache key
+     * @returns the uncompressed (if enabled), parsed and typed data from the cache
+     */
+    async getOrSet(key, callback, ...args) {
+        if (this.isLocallyCached(key))
+            return this.localCache.get(key);
+        let value;
+        const cachedValue = await this.getRaw(key);
+        if (cachedValue !== null) {
+            value = Cache.uncompress(key, cachedValue);
+        }
+        else {
+            value = await callback(...args);
+            await this.setRaw(key, Cache.compress(key, value));
+        }
+        this.setLocally(key, value);
+        return value;
+    }
+    /** @notice Set with retrials */
+    async safeSet(key, value) {
+        return await withRetry(withTimeout, [this.set(key, value), REDIS_CRON_WRITE_TIMEOUT], REDIS_RETRIES);
+    }
+}
+export const Redis = new Cache();

package/dist/src/cache/redis.js

@@ -0,0 +1,49 @@
+import { log } from "../utils/logger";
+import { createClient } from "redis";
+const REDISHOST = process.env.REDISHOST || "redis";
+const REDISPORT = !!process.env.REDISPORT ? Number(process.env.REDISPORT) : 6379;
+const REDISPASSWORD = process.env.REDISPASSWORD || "";
+export const REDIS_RETRIES = 0;
+export const REDIS_READ_TIMEOUT = !!process.env.REDIS_READ_TIMEOUT
+    ? Number.parseInt(process.env.REDIS_READ_TIMEOUT)
+    : Bun.env.NODE_ENV === "production"
+        ? 4_000
+        : 10 * 2_000;
+export const REDIS_WRITE_TIMEOUT = 4000;
+export const REDIS_CRON_READ_TIMEOUT = 5000;
+export const REDIS_CRON_WRITE_TIMEOUT = 10000;
+export var TTLType;
+(function (TTLType) {
+    TTLType[TTLType["HalfBlock"] = 4] = "HalfBlock";
+    TTLType[TTLType["Block"] = 11] = "Block";
+    TTLType[TTLType["Seconds30"] = 30] = "Seconds30";
+    TTLType[TTLType["Minutes2"] = 120] = "Minutes2";
+    TTLType[TTLType["Minutes3"] = 180] = "Minutes3";
+    TTLType[TTLType["Minutes5"] = 300] = "Minutes5";
+    TTLType[TTLType["Minutes10"] = 600] = "Minutes10";
+    TTLType[TTLType["Minutes25"] = 1500] = "Minutes25";
+    TTLType[TTLType["Minutes30"] = 1800] = "Minutes30";
+    TTLType[TTLType["Minutes35"] = 2100] = "Minutes35";
+    TTLType[TTLType["Hours3"] = 10800] = "Hours3";
+    TTLType[TTLType["Hours12"] = 43200] = "Hours12";
+    TTLType[TTLType["Day"] = 86400] = "Day";
+    TTLType[TTLType["Week"] = 604800] = "Week";
+})(TTLType || (TTLType = {}));
+/** Redis client
+ * @dev About how handling client connections -> https://stackoverflow.com/questions/22387187/node-js-express-redis-when-to-close-connection
+ * @dev Also -> https://github.com/redis/node-redis/issues/568
+ */
+const redisConfig = {
+    url: `redis://${REDISHOST}:${REDISPORT}`,
+    socket: REDISHOST === "redis" ? undefined : { tls: true },
+    password: REDISPASSWORD,
+};
+export const redisClient = createClient(redisConfig);
+redisClient.on("error", error => {
+    log.error("Redis", error);
+});
+redisClient.connect();
+redisClient.on("end", () => log.info("Redis: disconnected"));
+redisClient.on("ready", () => {
+    log.debug("Redis: connected!");
+});