@merkl/api 0.16.5 → 0.16.7

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