@merkl/api 0.16.6 → 0.16.7

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

@@ -1,8 +1,10 @@
 import { Redis } from "../../cache";
 import { campaignsToOldFormat } from "../../libs/deprecated-merklv3";
-import { AprService, CampaignService, OpportunityService } from "../../modules/v4";
+import { AprService } from "../../modules/v4/apr";
 import { CacheService } from "../../modules/v4/cache";
 import { TTLPresets } from "../../modules/v4/cache/cache.model";
+import { CampaignService } from "../../modules/v4/campaign";
+import { OpportunityService } from "../../modules/v4/opportunity";
 import { OpportunityRepository } from "../../modules/v4/opportunity/opportunity.repository";
 import { RewardService } from "../../modules/v4/reward";
 import { TvlService } from "../../modules/v4/tvl";

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

@@ -1,4 +1,4 @@
-import { TokenService } from "../../modules/v4";
+import { TokenService } from "../../modules/v4/token";
 import { log } from "../../utils/logger";
 import { Pricer } from "../../utils/pricer";
 export const updatePrices = async () => {

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

@@ -1316,6 +1316,7 @@ declare const eden: {
                     headers?: Record<string, unknown> | undefined;
                     query: {
                         tokenAddress?: string | undefined;
+                        verified?: boolean | undefined;
                         additionalTokenAddresses?: string[] | undefined;
                         chainId: number;
                         userAddress: string;
@@ -2066,7 +2067,7 @@ declare const eden: {
                                 proofs: string[];
                             }, "breakdowns"> & {
                                 breakdowns: {
-                                    opportunity: import("../modules/v4").Opportunity["model"];
+                                    opportunity: import("../modules/v4/opportunity").Opportunity["model"];
                                     claimed: bigint;
                                     amount: bigint;
                                     pending: bigint;
@@ -2780,7 +2781,7 @@ declare const eden: {
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: (import("../modules/v4/claims").ClaimModel & {
-                    token?: import("../modules/v4").Token["model"];
+                    token?: import("../modules/v4/token").Token["model"];
                 })[];
             }>>;
         }) & {};
@@ -4427,6 +4428,7 @@ declare const eden: {
                     headers?: Record<string, unknown> | undefined;
                     query: {
                         tokenAddress?: string | undefined;
+                        verified?: boolean | undefined;
                         additionalTokenAddresses?: string[] | undefined;
                         chainId: number;
                         userAddress: string;
@@ -5177,7 +5179,7 @@ declare const eden: {
                                 proofs: string[];
                             }, "breakdowns"> & {
                                 breakdowns: {
-                                    opportunity: import("../modules/v4").Opportunity["model"];
+                                    opportunity: import("../modules/v4/opportunity").Opportunity["model"];
                                     claimed: bigint;
                                     amount: bigint;
                                     pending: bigint;
@@ -5891,7 +5893,7 @@ declare const eden: {
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: (import("../modules/v4/claims").ClaimModel & {
-                    token?: import("../modules/v4").Token["model"];
+                    token?: import("../modules/v4/token").Token["model"];
                 })[];
             }>>;
         }) & {};
@@ -8448,6 +8450,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     params: {};
                     query: {
                         tokenAddress?: string | undefined;
+                        verified?: boolean | undefined;
                         additionalTokenAddresses?: string[] | undefined;
                         chainId: number;
                         userAddress: string;
@@ -9493,7 +9496,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                         proofs: string[];
                                     }, "breakdowns"> & {
                                         breakdowns: {
-                                            opportunity: import("../modules/v4").Opportunity["model"];
+                                            opportunity: import("../modules/v4/opportunity").Opportunity["model"];
                                             claimed: bigint;
                                             amount: bigint;
                                             pending: bigint;
@@ -10344,7 +10347,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     headers: unknown;
                     response: {
                         200: (import("../modules/v4/claims").ClaimModel & {
-                            token?: import("../modules/v4").Token["model"];
+                            token?: import("../modules/v4/token").Token["model"];
                         })[];
                     };
                 };
@@ -13000,6 +13003,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     headers?: Record<string, unknown> | undefined;
                     query: {
                         tokenAddress?: string | undefined;
+                        verified?: boolean | undefined;
                         additionalTokenAddresses?: string[] | undefined;
                         chainId: number;
                         userAddress: string;
@@ -13750,7 +13754,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 proofs: string[];
                             }, "breakdowns"> & {
                                 breakdowns: {
-                                    opportunity: import("../modules/v4").Opportunity["model"];
+                                    opportunity: import("../modules/v4/opportunity").Opportunity["model"];
                                     claimed: bigint;
                                     amount: bigint;
                                     pending: bigint;
@@ -14464,7 +14468,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: (import("../modules/v4/claims").ClaimModel & {
-                    token?: import("../modules/v4").Token["model"];
+                    token?: import("../modules/v4/token").Token["model"];
                 })[];
             }>>;
         }) & {};
@@ -16111,6 +16115,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     headers?: Record<string, unknown> | undefined;
                     query: {
                         tokenAddress?: string | undefined;
+                        verified?: boolean | undefined;
                         additionalTokenAddresses?: string[] | undefined;
                         chainId: number;
                         userAddress: string;
@@ -16861,7 +16866,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 proofs: string[];
                             }, "breakdowns"> & {
                                 breakdowns: {
-                                    opportunity: import("../modules/v4").Opportunity["model"];
+                                    opportunity: import("../modules/v4/opportunity").Opportunity["model"];
                                     claimed: bigint;
                                     amount: bigint;
                                     pending: bigint;
@@ -17575,7 +17580,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: (import("../modules/v4/claims").ClaimModel & {
-                    token?: import("../modules/v4").Token["model"];
+                    token?: import("../modules/v4/token").Token["model"];
                 })[];
             }>>;
         }) & {};

package/dist/src/index.d.ts

@@ -1528,6 +1528,7 @@ declare const app: Elysia<"", false, {
                     params: {};
                     query: {
                         tokenAddress?: string | undefined;
+                        verified?: boolean | undefined;
                         additionalTokenAddresses?: string[] | undefined;
                         chainId: number;
                         userAddress: string;
@@ -2573,7 +2574,7 @@ declare const app: Elysia<"", false, {
                                         proofs: string[];
                                     }, "breakdowns"> & {
                                         breakdowns: {
-                                            opportunity: import("./modules/v4").Opportunity["model"];
+                                            opportunity: import("./modules/v4/opportunity").Opportunity["model"];
                                             claimed: bigint;
                                             amount: bigint;
                                             pending: bigint;
@@ -3424,7 +3425,7 @@ declare const app: Elysia<"", false, {
                     headers: unknown;
                     response: {
                         200: (import("./modules/v4/claims").ClaimModel & {
-                            token?: import("./modules/v4").Token["model"];
+                            token?: import("./modules/v4/token").Token["model"];
                         })[];
                     };
                 };

package/dist/src/libs/getTokensList.d.ts

@@ -14,14 +14,4 @@ export interface Token {
 export interface TokenInfoListType {
     [symbol: string]: Token;
 }
-export interface TokenList {
-    [chainId: number]: TokenInfoListType;
-}
 export declare const getTokensListWithCache: () => Promise<TokenList>;
-export type MerklTokens = {
-    [address: string]: {
-        symbol: string;
-        decimals: number;
-    };
-};
-export declare function getMerklTokenList(chainId: number): Promise<MerklTokens>;

package/dist/src/libs/getTokensList.js

@@ -1,5 +1,4 @@
 import { Redis } from "../cache";
-import { engineDbClient } from "../utils/prisma";
 import axios from "axios";
 import { log } from "../utils/logger";
 async function getTokensList() {
@@ -14,24 +13,5 @@ async function getTokensList() {
     }
     return res;
 }
+// Deprecated
 export const getTokensListWithCache = async () => await Redis.getOrSet("TokenList", getTokensList);
-export async function getMerklTokenList(chainId) {
-    const tokensRaws = await engineDbClient.tokens.findMany({
-        select: {
-            address: true,
-            decimals: true,
-            symbol: true,
-        },
-        where: {
-            chainId,
-        },
-    });
-    const tokens = {};
-    for (const token of tokensRaws) {
-        tokens[token.address] = {
-            decimals: token.decimals,
-            symbol: token.symbol,
-        };
-    }
-    return tokens;
-}

package/dist/src/libs/merklChainData.js

@@ -1,8 +1,8 @@
 import { Redis } from "../cache";
+import { TokenService } from "../modules/v4/token";
 import { Interface } from "@ethersproject/abi";
 import { BN2Number, DistributionCreator__factory, Distributor__factory, NETWORK_LABELS, NULL_ADDRESS, registry, } from "@sdk";
 import { batchMulticallCallWithRetry } from "../utils/generic";
-import { getMerklTokenList, getTokensListWithCache } from "./getTokensList";
 const DistributorInterface = Distributor__factory.createInterface();
 const DistributorCreatorInterface = DistributionCreator__factory.createInterface();
 const MTW_INTERFACE = new Interface([
@@ -10,7 +10,7 @@ const MTW_INTERFACE = new Interface([
     "function token() external view returns (address)",
 ]);
 export async function merklChainData(chainId) {
-    const tokens = await getMerklTokenList(chainId);
+    const tokens = await TokenService.findManyObjectPerAddress({ chainId, verified: true });
     const distributorAddress = registry(chainId)?.Merkl?.Distributor;
     const distributionCreatorAddress = registry(chainId)?.Merkl?.DistributionCreator;
     if (!distributorAddress || !distributionCreatorAddress) {
@@ -54,7 +54,6 @@ export async function merklChainData(chainId) {
         },
     ];
     const result = await batchMulticallCallWithRetry(chainId, { calls });
-    const tokenList = await getTokensListWithCache();
     let i = 0;
     const merkleRoot = DistributorInterface.decodeFunctionResult("getMerkleRoot", result[i++].returnData)[0]?.toString();
     const treeRoot = DistributorInterface.decodeFunctionResult("tree", result[i++].returnData)[0].toString();
@@ -67,16 +66,8 @@ export async function merklChainData(chainId) {
     }
     catch { }
     const validRewardTokens = DistributorCreatorInterface.decodeFunctionResult("getValidRewardTokens()", result[i++].returnData)[0].map((t) => {
-        const decimals = tokens[t.token]?.decimals
-            ? tokens[t.token]?.decimals
-            : tokenList[chainId]?.[t.token]?.decimals
-                ? tokenList[chainId][t.token].decimals
-                : undefined;
-        const symbol = tokens[t.token]?.symbol
-            ? tokens[t.token]?.symbol
-            : tokenList[chainId]?.[t.token]?.symbol
-                ? tokenList[chainId][t.token].symbol
-                : undefined;
+        const decimals = tokens[t.token]?.decimals ? tokens[t.token]?.decimals : undefined;
+        const symbol = tokens[t.token]?.symbol ? tokens[t.token]?.symbol : undefined;
         return {
             decimals: decimals,
             minimumAmountPerEpoch: decimals
@@ -86,17 +77,6 @@ export async function merklChainData(chainId) {
             token: t.token,
         };
     });
-    const missingSymbols = validRewardTokens.filter(t => !t.symbol || !t.decimals);
-    for (const token of missingSymbols) {
-        if (!tokenList[chainId])
-            continue;
-        const tokenInfo = tokenList[chainId][token.token];
-        if (!tokenInfo)
-            continue;
-        token.symbol = tokenInfo.symbol;
-        token.decimals = tokenInfo.decimals;
-        token.minimumAmountPerEpoch = BN2Number(token.minimumAmountPerEpoch, tokenInfo.decimals);
-    }
     const validRewardTokensCalls = validRewardTokens.reduce((acc, t) => {
         acc.push({
             allowFailure: true,

package/dist/src/libs/tokens/balances.js

@@ -1,6 +1,6 @@
+import { TokenService } from "../../modules/v4/token";
 import { ChainId, ChainInteractionService, ETH_ADDRESS, ETH_ZKSYNC_ADDRESS, Erc20__factory, EthOnZKSync_INTERFACE, NETWORK_LABELS, } from "@sdk";
 import { log } from "../../utils/logger";
-import { getTokensListWithCache } from "../getTokensList";
 export async function getOnlyUserBalance(chainId, userAddress, tokenAddresses) {
     const calls = [];
     const ERC20_Interface = Erc20__factory.createInterface();
@@ -40,7 +40,7 @@ export async function getOnlyUserBalance(chainId, userAddress, tokenAddresses) {
     return res;
 }
 export async function getUserBalances(user, chainId, tokenAddresses) {
-    const tokens = (await getTokensListWithCache())?.[chainId];
+    const tokens = await TokenService.findManyObjectPerAddress({ chainId, verified: true });
     if (!tokens) {
         log.debug("❌ Chain not supported");
         return {

package/dist/src/modules/v4/campaign/campaign.model.d.ts

@@ -1,5 +1,5 @@
 import type { Resource } from "../prisma";
-import { type Token } from "../token";
+import { type Token } from "../token/token.model";
 import type { Campaign as CampaignEnum, CampaignParameters } from "@sdk";
 import { type Chain } from "../chain/chain.model";
 import { type Status } from "../status/status.model";

package/dist/src/modules/v4/campaign/campaign.model.js

@@ -1,4 +1,4 @@
-import { TokenResourceDto } from "../token";
+import { TokenResourceDto } from "../token/token.model";
 import { t } from "elysia";
 import { ChainResourceDto } from "../chain/chain.model";
 import { CampaignStatusResourceDto } from "../status/status.model";

package/dist/src/modules/v4/claims/claims.controller.d.ts

@@ -25,7 +25,7 @@ export declare const ClaimController: Elysia<"/claims", false, {
                 headers: unknown;
                 response: {
                     200: (import("./claims.model").ClaimModel & {
-                        token?: import("..").Token["model"];
+                        token?: import("../token").Token["model"];
                     })[];
                 };
             };

package/dist/src/modules/v4/reward/reward.model.d.ts

@@ -1,5 +1,5 @@
 import type { Resource } from "../prisma";
-import { type Token } from "../token";
+import { type Token } from "../token/token.model";
 /**
  * Rewards Record
  * @description Describes one rewards value snapshot for an opportunity

package/dist/src/modules/v4/reward/reward.model.js

@@ -1,5 +1,5 @@
 import { t } from "elysia";
-import { TokenResourceDto } from "../token";
+import { TokenResourceDto } from "../token/token.model";
 // ─── DTOs ────────────────────────────────────────────────────────────────────
 export const DailyRewardsBreakdownRecordResourceDto = t.Object({
     id: t.Number(),

package/dist/src/modules/v4/router.d.ts

@@ -1398,6 +1398,7 @@ export declare const v4: Elysia<"/v4", false, {
                     params: {};
                     query: {
                         tokenAddress?: string | undefined;
+                        verified?: boolean | undefined;
                         additionalTokenAddresses?: string[] | undefined;
                         chainId: number;
                         userAddress: string;

package/dist/src/modules/v4/token/token.controller.d.ts

@@ -113,6 +113,7 @@ export declare const TokenController: Elysia<"/tokens", false, {
                 params: {};
                 query: {
                     tokenAddress?: string | undefined;
+                    verified?: boolean | undefined;
                     additionalTokenAddresses?: string[] | undefined;
                     chainId: number;
                     userAddress: string;

package/dist/src/modules/v4/token/token.model.d.ts

@@ -47,6 +47,7 @@ export declare const TokenDto: import("@sinclair/typebox").TObject<{
 export declare const GetTokenBalanceDto: import("@sinclair/typebox").TObject<{
     chainId: import("@sinclair/typebox").TNumber;
     userAddress: import("@sinclair/typebox").TString;
+    verified: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     tokenAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     additionalTokenAddresses: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
 }>;

package/dist/src/modules/v4/token/token.model.js

@@ -36,6 +36,7 @@ export const TokenDto = t.Object({
 export const GetTokenBalanceDto = t.Object({
     chainId: t.Numeric(),
     userAddress: t.String(),
+    verified: t.Optional(t.Boolean()),
     tokenAddress: t.Optional(t.String({ description: "If provided, the default verified token balances won't be included" })),
     additionalTokenAddresses: t.Optional(t.Array(t.String())),
 });

package/dist/src/modules/v4/token/token.service.d.ts

@@ -163,6 +163,19 @@ export declare abstract class TokenService {
     } & {
         price?: number | null | undefined;
     })[]>;
+    static findManyObjectPerAddress(query: GetTokenQueryModel): Promise<Record<string, {
+        symbol: string;
+        name: string | null;
+        id: string;
+        icon: string;
+        chainId: number;
+        address: string;
+        decimals: number;
+        verified: boolean;
+        isTest: boolean;
+    } & {
+        price?: number | null | undefined;
+    }>>;
     /**
      * Get value of tokens
      * @param tokenAmounts address/chain + amount of token

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

@@ -139,23 +139,6 @@ export class TokenService {
                     catch (e) {
                         console.error(e);
                     }
-                    try {
-                        const res = await TokenRepository.create({
-                            id: TokenService.hashId({ chainId: Number.parseInt(chain), address: token.address }),
-                            chainId: Number.parseInt(chain),
-                            address: token.address,
-                            name: token.name,
-                            symbol: token.symbol,
-                            verified: true,
-                            decimals: token.decimals,
-                            icon: token.logoURI,
-                            isTest: false,
-                        });
-                        log.local(`Token created: ${res?.symbol} on ${NETWORK_LABELS[Number.parseInt(chain)]}`);
-                    }
-                    catch (e) {
-                        console.error(e);
-                    }
                 }
                 try {
                     await apiDbClient.token.update({
@@ -236,6 +219,12 @@ export class TokenService {
     static async findMany(query) {
         return (await TokenRepository.findMany(query)).map(TokenService.format);
     }
+    static async findManyObjectPerAddress(query) {
+        return (await TokenService.findMany(query)).reduce((acc, token) => {
+            acc[token.address] = token;
+            return acc;
+        }, {});
+    }
     /**
      * Get value of tokens
      * @param tokenAmounts address/chain + amount of token

package/dist/src/modules/v4/user/user.controller.d.ts

@@ -198,7 +198,7 @@ export declare const UserController: Elysia<"/users", false, {
                                     proofs: string[];
                                 }, "breakdowns"> & {
                                     breakdowns: {
-                                        opportunity: import("..").Opportunity["model"];
+                                        opportunity: import("../opportunity").Opportunity["model"];
                                         claimed: bigint;
                                         amount: bigint;
                                         pending: bigint;

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

@@ -1,11 +1,11 @@
 import { Redis } from "../../cache";
+import { TokenService } from "../../modules/v4/token";
 import { getLastBlockBeforeWithCache } from "../../utils/lastBlockBefore";
 import { BN2Number, ChainId, DAY, ERC20Interface } from "@sdk";
 import { t } from "elysia";
 import { utils } from "ethers";
 import moment from "moment";
 import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
-import { getTokensListWithCache } from "../../libs/getTokensList";
 import { batchMulticallCallWithRetry } from "../../utils/generic";
 import { log } from "../../utils/logger";
 import { providers } from "../../utils/providers";
@@ -32,13 +32,16 @@ const CONSTANTS = {
     ],
 };
 const getLostYield = async (user) => {
-    const tokenList = await getTokensListWithCache();
     const result = {};
     const now = moment().unix();
     const LOOKBACK = 30 * DAY;
     const AVERAGING_PERIOD = 2 * DAY;
     const promises = Object.keys(CONSTANTS).map(chainId => (async () => {
         try {
+            const tokenList = await TokenService.findManyObjectPerAddress({
+                chainId: Number.parseInt(chainId),
+                verified: true,
+            });
             result[chainId] = {};
             for (const token of CONSTANTS[Number.parseInt(chainId)]) {
                 result[chainId][token] = { total: 0, yield: 0 };
@@ -64,7 +67,7 @@ const getLostYield = async (user) => {
                     const results = await batchMulticallCallWithRetry(Number.parseInt(chainId), { calls, blockNumber });
                     let i = 0;
                     for (const token of CONSTANTS[Number.parseInt(chainId)]) {
-                        const tokenDetails = tokenList[Number.parseInt(chainId)][utils.getAddress(token)];
+                        const tokenDetails = tokenList[utils.getAddress(token)];
                         const balance = ERC20Interface.decodeFunctionResult("balanceOf", results[i++].returnData)[0];
                         result[chainId][token].total += BN2Number(balance, tokenDetails.decimals);
                     }

package/dist/src/utils/prices/priceService.js

@@ -263,7 +263,7 @@ export default class PriceService {
             this._prices[`r${xUpper}`] = this._prices[x];
             this._prices[`variableDebt${xUpper}`] = this._prices[x];
         }
-        /** Fill all BorrowStaker prices */
+        /** Deprecated - Fill all BorrowStaker prices */
         const tokens = await getTokensListWithCache();
         for (const chainIdString of Object.keys(tokens)) {
             const chainId = Number.parseInt(chainIdString);