@merkl/api 0.16.6 → 0.16.8

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

@@ -53,18 +53,6 @@ export declare class StatusService {
         computedUntil: bigint;
         startTimestamp: bigint;
         endTimestamp: bigint;
-        CampaignStatus: {
-            error: string;
-            details: import("database/api/.generated/runtime/library").JsonValue;
-            status: import("../../../../database/api/.generated").$Enums.RunStatus;
-            campaignId: string;
-            computedUntil: bigint;
-            processingStarted: bigint;
-        }[];
-        Opportunity: {
-            name: string;
-            id: string;
-        };
         computeChainId: number;
         distributionChainId: number;
         campaignId: string;
@@ -73,5 +61,17 @@ export declare class StatusService {
             address: string;
             isTest: boolean;
         };
+        Opportunity: {
+            name: string;
+            id: string;
+        };
+        CampaignStatus: {
+            error: string;
+            details: import("database/api/.generated/runtime/library").JsonValue;
+            status: import("../../../../database/api/.generated").$Enums.RunStatus;
+            campaignId: string;
+            computedUntil: bigint;
+            processingStarted: bigint;
+        }[];
     }[]>;
 }

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

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

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/routes/v3/opportunity.d.ts

@@ -43,9 +43,9 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
                 type?: undefined;
                 tag?: string | undefined;
                 chainId?: undefined;
-                mainParameter?: string | undefined;
                 action?: undefined;
                 campaigns?: boolean | undefined;
+                mainParameter?: string | undefined;
                 testTokens?: boolean | undefined;
             };
             headers: unknown;

package/dist/src/routes/v3/rewards.d.ts

@@ -36,8 +36,8 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
                                     pending?: string | undefined;
                                     symbol: string;
                                     token: string;
-                                    mainParameter: string;
                                     decimals: number;
+                                    mainParameter: string;
                                     unclaimed: string;
                                     accumulated: string;
                                 };

package/dist/src/routes/v3/rewardsReport.d.ts

@@ -25,8 +25,8 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
             params: {};
             query: {
                 from?: number | undefined;
-                to?: number | undefined;
                 mainParameter?: string | undefined;
+                to?: number | undefined;
                 chainId: number;
                 campaignId: string;
             };

package/dist/src/routes/v3/router.d.ts

@@ -412,9 +412,9 @@ export declare const v3: Elysia<"/v3", false, {
                     type?: undefined;
                     tag?: string | undefined;
                     chainId?: undefined;
-                    mainParameter?: string | undefined;
                     action?: undefined;
                     campaigns?: boolean | undefined;
+                    mainParameter?: string | undefined;
                     testTokens?: boolean | undefined;
                 };
                 headers: unknown;
@@ -608,8 +608,8 @@ export declare const v3: Elysia<"/v3", false, {
                                         pending?: string | undefined;
                                         symbol: string;
                                         token: string;
-                                        mainParameter: string;
                                         decimals: number;
+                                        mainParameter: string;
                                         unclaimed: string;
                                         accumulated: string;
                                     };
@@ -639,8 +639,8 @@ export declare const v3: Elysia<"/v3", false, {
                 params: {};
                 query: {
                     from?: number | undefined;
-                    to?: number | undefined;
                     mainParameter?: string | undefined;
+                    to?: number | undefined;
                     chainId: number;
                     campaignId: string;
                 };
@@ -743,9 +743,9 @@ export declare const v3: Elysia<"/v3", false, {
                 body: unknown;
                 params: {};
                 query: {
-                    mainParameter?: string | undefined;
                     rewardToken?: string | undefined;
                     proof?: string | undefined;
+                    mainParameter?: string | undefined;
                     reloadChainId?: number | undefined;
                     chainId: never;
                     user: string;

package/dist/src/routes/v3/userRewards.d.ts

@@ -25,9 +25,9 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
             body: unknown;
             params: {};
             query: {
-                mainParameter?: string | undefined;
                 rewardToken?: string | undefined;
                 proof?: string | undefined;
+                mainParameter?: string | undefined;
                 reloadChainId?: number | undefined;
                 chainId: never;
                 user: string;

package/dist/src/utils/generateCardName.js

@@ -35,10 +35,6 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""], displ
             return cardName;
         }
         case tokenType.balancerV3: {
-            const symbols = [];
-            for (let i = 0; i < typeInfo.numberTokens; i++) {
-                symbols.push(typeInfo[`symbolToken${i}`]);
-            }
             if (campaign.computeChainId === ChainId.SONIC) {
                 typeInfo.protocol = "Beets";
             }

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);