@merkl/api 0.10.129 → 0.10.131

package/dist/database/engine/.generated/wasm.js

@@ -0,0 +1,415 @@
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+const {
+  Decimal,
+  objectEnumValues,
+  makeStrictEnum,
+  Public,
+  getRuntime,
+  skip
+} = require('./runtime/index-browser.js')
+
+
+const Prisma = {}
+
+exports.Prisma = Prisma
+exports.$Enums = {}
+
+/**
+ * Prisma Client JS version: 6.0.1
+ * Query Engine version: 5dbef10bdbfb579e07d35cc85fb1518d357cb99e
+ */
+Prisma.prismaVersion = {
+  client: "6.0.1",
+  engine: "5dbef10bdbfb579e07d35cc85fb1518d357cb99e"
+}
+
+Prisma.PrismaClientKnownRequestError = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`PrismaClientKnownRequestError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)};
+Prisma.PrismaClientUnknownRequestError = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`PrismaClientUnknownRequestError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+Prisma.PrismaClientRustPanicError = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`PrismaClientRustPanicError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+Prisma.PrismaClientInitializationError = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`PrismaClientInitializationError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+Prisma.PrismaClientValidationError = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`PrismaClientValidationError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+Prisma.Decimal = Decimal
+
+/**
+ * Re-export of sql-template-tag
+ */
+Prisma.sql = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`sqltag is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+Prisma.empty = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`empty is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+Prisma.join = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`join is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+Prisma.raw = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`raw is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+Prisma.validator = Public.validator
+
+/**
+* Extensions
+*/
+Prisma.getExtensionContext = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`Extensions.getExtensionContext is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+Prisma.defineExtension = () => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(`Extensions.defineExtension is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`,
+)}
+
+/**
+ * Shorthand utilities for JSON filtering
+ */
+Prisma.DbNull = objectEnumValues.instances.DbNull
+Prisma.JsonNull = objectEnumValues.instances.JsonNull
+Prisma.AnyNull = objectEnumValues.instances.AnyNull
+
+Prisma.NullTypes = {
+  DbNull: objectEnumValues.classes.DbNull,
+  JsonNull: objectEnumValues.classes.JsonNull,
+  AnyNull: objectEnumValues.classes.AnyNull
+}
+
+
+
+/**
+ * Enums
+ */
+
+exports.Prisma.TransactionIsolationLevel = makeStrictEnum({
+  ReadUncommitted: 'ReadUncommitted',
+  ReadCommitted: 'ReadCommitted',
+  RepeatableRead: 'RepeatableRead',
+  Serializable: 'Serializable'
+});
+
+exports.Prisma.TempLeavesScalarFieldEnum = {
+  chainId: 'chainId',
+  campaignId: 'campaignId',
+  recipient: 'recipient',
+  reason: 'reason',
+  rewardToken: 'rewardToken',
+  amount: 'amount',
+  auxiliaryData1: 'auxiliaryData1',
+  auxiliaryData2: 'auxiliaryData2',
+  lastProcessedTimestamp: 'lastProcessedTimestamp'
+};
+
+exports.Prisma.RelationLoadStrategy = {
+  query: 'query',
+  join: 'join'
+};
+
+exports.Prisma.LeavesScalarFieldEnum = {
+  chainId: 'chainId',
+  root: 'root',
+  campaignId: 'campaignId',
+  recipient: 'recipient',
+  reason: 'reason',
+  rewardToken: 'rewardToken',
+  amount: 'amount',
+  auxiliaryData1: 'auxiliaryData1',
+  auxiliaryData2: 'auxiliaryData2',
+  lastProcessedTimestamp: 'lastProcessedTimestamp'
+};
+
+exports.Prisma.ProofsScalarFieldEnum = {
+  chainId: 'chainId',
+  root: 'root',
+  recipient: 'recipient',
+  rewardToken: 'rewardToken',
+  proof: 'proof'
+};
+
+exports.Prisma.MerklRootsScalarFieldEnum = {
+  chainId: 'chainId',
+  epoch: 'epoch',
+  timestamp: 'timestamp',
+  root: 'root'
+};
+
+exports.Prisma.CampaignsScalarFieldEnum = {
+  chainId: 'chainId',
+  computeChainId: 'computeChainId',
+  index: 'index',
+  campaignId: 'campaignId',
+  creator: 'creator',
+  campaignType: 'campaignType',
+  campaignSubType: 'campaignSubType',
+  rewardToken: 'rewardToken',
+  amount: 'amount',
+  startTimestamp: 'startTimestamp',
+  endTimestamp: 'endTimestamp',
+  mainParameter: 'mainParameter',
+  campaignParameters: 'campaignParameters'
+};
+
+exports.Prisma.CampaignsToProcessScalarFieldEnum = {
+  chainId: 'chainId',
+  computeChainId: 'computeChainId',
+  index: 'index',
+  campaignId: 'campaignId',
+  creator: 'creator',
+  campaignType: 'campaignType',
+  campaignSubType: 'campaignSubType',
+  rewardToken: 'rewardToken',
+  amount: 'amount',
+  startTimestamp: 'startTimestamp',
+  endTimestamp: 'endTimestamp',
+  mainParameter: 'mainParameter',
+  campaignParameters: 'campaignParameters',
+  lastProcessedTimestamp: 'lastProcessedTimestamp',
+  processUntilTimestamp: 'processUntilTimestamp',
+  jobIndex: 'jobIndex'
+};
+
+exports.Prisma.ClaimsScalarFieldEnum = {
+  chainId: 'chainId',
+  recipient: 'recipient',
+  campaignId: 'campaignId',
+  rewardToken: 'rewardToken',
+  reason: 'reason',
+  root: 'root',
+  claimed: 'claimed',
+  timestamp: 'timestamp'
+};
+
+exports.Prisma.ClaimsOverTimeScalarFieldEnum = {
+  chainId: 'chainId',
+  recipient: 'recipient',
+  campaignId: 'campaignId',
+  rewardToken: 'rewardToken',
+  reason: 'reason',
+  root: 'root',
+  claimed: 'claimed',
+  timestamp: 'timestamp'
+};
+
+exports.Prisma.ALMsScalarFieldEnum = {
+  chainId: 'chainId',
+  campaignId: 'campaignId',
+  name: 'name',
+  type: 'type',
+  address: 'address',
+  target: 'target',
+  owner: 'owner',
+  underlyingPool: 'underlyingPool'
+};
+
+exports.Prisma.ERC20HoldersScalarFieldEnum = {
+  chainId: 'chainId',
+  token: 'token',
+  holders: 'holders',
+  blockNumber: 'blockNumber'
+};
+
+exports.Prisma.TokensScalarFieldEnum = {
+  chainId: 'chainId',
+  address: 'address',
+  symbol: 'symbol',
+  decimals: 'decimals'
+};
+
+exports.Prisma.StateSaveScalarFieldEnum = {
+  id: 'id',
+  blockNumber: 'blockNumber',
+  state: 'state'
+};
+
+exports.Prisma.CampaignCreatorsScalarFieldEnum = {
+  address: 'address',
+  tags: 'tags'
+};
+
+exports.Prisma.SortOrder = {
+  asc: 'asc',
+  desc: 'desc'
+};
+
+exports.Prisma.JsonNullValueInput = {
+  JsonNull: Prisma.JsonNull
+};
+
+exports.Prisma.QueryMode = {
+  default: 'default',
+  insensitive: 'insensitive'
+};
+
+exports.Prisma.TempLeavesOrderByRelevanceFieldEnum = {
+  campaignId: 'campaignId',
+  recipient: 'recipient',
+  reason: 'reason',
+  rewardToken: 'rewardToken',
+  amount: 'amount'
+};
+
+exports.Prisma.LeavesOrderByRelevanceFieldEnum = {
+  root: 'root',
+  campaignId: 'campaignId',
+  recipient: 'recipient',
+  reason: 'reason',
+  rewardToken: 'rewardToken',
+  amount: 'amount'
+};
+
+exports.Prisma.ProofsOrderByRelevanceFieldEnum = {
+  root: 'root',
+  recipient: 'recipient',
+  rewardToken: 'rewardToken',
+  proof: 'proof'
+};
+
+exports.Prisma.MerklRootsOrderByRelevanceFieldEnum = {
+  root: 'root'
+};
+
+exports.Prisma.JsonNullValueFilter = {
+  DbNull: Prisma.DbNull,
+  JsonNull: Prisma.JsonNull,
+  AnyNull: Prisma.AnyNull
+};
+
+exports.Prisma.CampaignsOrderByRelevanceFieldEnum = {
+  campaignId: 'campaignId',
+  creator: 'creator',
+  rewardToken: 'rewardToken',
+  amount: 'amount',
+  mainParameter: 'mainParameter'
+};
+
+exports.Prisma.CampaignsToProcessOrderByRelevanceFieldEnum = {
+  campaignId: 'campaignId',
+  creator: 'creator',
+  rewardToken: 'rewardToken',
+  amount: 'amount',
+  mainParameter: 'mainParameter'
+};
+
+exports.Prisma.ClaimsOrderByRelevanceFieldEnum = {
+  recipient: 'recipient',
+  campaignId: 'campaignId',
+  rewardToken: 'rewardToken',
+  reason: 'reason',
+  root: 'root',
+  claimed: 'claimed'
+};
+
+exports.Prisma.ClaimsOverTimeOrderByRelevanceFieldEnum = {
+  recipient: 'recipient',
+  campaignId: 'campaignId',
+  rewardToken: 'rewardToken',
+  reason: 'reason',
+  root: 'root',
+  claimed: 'claimed'
+};
+
+exports.Prisma.ALMsOrderByRelevanceFieldEnum = {
+  campaignId: 'campaignId',
+  name: 'name',
+  type: 'type',
+  address: 'address',
+  target: 'target',
+  owner: 'owner',
+  underlyingPool: 'underlyingPool'
+};
+
+exports.Prisma.ERC20HoldersOrderByRelevanceFieldEnum = {
+  token: 'token',
+  holders: 'holders'
+};
+
+exports.Prisma.TokensOrderByRelevanceFieldEnum = {
+  address: 'address',
+  symbol: 'symbol'
+};
+
+exports.Prisma.StateSaveOrderByRelevanceFieldEnum = {
+  id: 'id'
+};
+
+exports.Prisma.CampaignCreatorsOrderByRelevanceFieldEnum = {
+  address: 'address',
+  tags: 'tags'
+};
+
+
+exports.Prisma.ModelName = {
+  TempLeaves: 'TempLeaves',
+  Leaves: 'Leaves',
+  Proofs: 'Proofs',
+  MerklRoots: 'MerklRoots',
+  Campaigns: 'Campaigns',
+  CampaignsToProcess: 'CampaignsToProcess',
+  Claims: 'Claims',
+  ClaimsOverTime: 'ClaimsOverTime',
+  ALMs: 'ALMs',
+  ERC20Holders: 'ERC20Holders',
+  Tokens: 'Tokens',
+  StateSave: 'StateSave',
+  CampaignCreators: 'CampaignCreators'
+};
+
+/**
+ * This is a stub Prisma Client that will error at runtime if called.
+ */
+class PrismaClient {
+  constructor() {
+    return new Proxy(this, {
+      get(target, prop) {
+        let message
+        const runtime = getRuntime()
+        if (runtime.isEdge) {
+          message = `PrismaClient is not configured to run in ${runtime.prettyName}. In order to run Prisma Client on edge runtime, either:
+- Use Prisma Accelerate: https://pris.ly/d/accelerate
+- Use Driver Adapters: https://pris.ly/d/driver-adapters
+`;
+        } else {
+          message = 'PrismaClient is unable to run in this browser environment, or has been bundled for the browser (running in `' + runtime.prettyName + '`).'
+        }
+        
+        message += `
+If this is unexpected, please open an issue: https://pris.ly/prisma-prisma-bug-report`
+
+        throw new Error(message)
+      }
+    })
+  }
+}
+
+exports.PrismaClient = PrismaClient
+
+Object.assign(exports, Prisma)

package/dist/src/backgroundJobs/index.js

@@ -0,0 +1,44 @@
+import { redisClient } from "../cache/redis";
+import { log } from "../utils/logger";
+import { engineDbClient } from "../utils/prisma";
+import { swagger } from "@elysiajs/swagger";
+import axios from "axios";
+import { Elysia } from "elysia";
+import { campaignsCacheUpdater } from "./jobs/campaignsCacheUpdater";
+import { healthCheck } from "./jobs/health";
+import { opportunityUpdater } from "./jobs/opportunityUpdater";
+import { priceUpdater } from "./jobs/priceUpdater";
+import { sync } from "./jobs/sync";
+// Axios with bun workaround
+axios.defaults.headers.common["Accept-Encoding"] = "gzip";
+const PORT = process.env.PORT || 3000;
+const app = new Elysia()
+    .use(swagger())
+    .get("/", () => "Merkl API")
+    .use(campaignsCacheUpdater) // /v3/update
+    .use(opportunityUpdater) // /v3/updateOpportunity
+    .use(priceUpdater) // /v3/updatePrices
+    .use(healthCheck) // /v3/health
+    .use(sync) // GET /jobs/api/sync-with-engine
+    .onError(ctx => {
+    console.error(ctx.error.message);
+    console.error(ctx.error.stack);
+    if (ctx.code === "NOT_FOUND")
+        return new Response(JSON.stringify({
+            path: ctx.path,
+            error: ctx.code,
+            message: "Path does not exist",
+        }), {
+            status: 404,
+        });
+    return (ctx.set.status = "Internal Server Error");
+})
+    .listen(PORT, ({ hostname, port }) => {
+    log.info(`🔄  Background Jobs started (${hostname}:${port})`);
+});
+// ─── Signal Handling ─────────────────────────────────────────────────────────
+process.on("SIGTERM", () => {
+    engineDbClient.$disconnect();
+    redisClient.disconnect();
+    process.exit();
+});

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"],
+    });
+};