@merkl/api 0.18.6 → 0.18.8

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

@@ -616,13 +616,6 @@ declare const eden: {
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;
@@ -4075,13 +4068,6 @@ declare const eden: {
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;
@@ -8000,13 +7986,6 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 price?: number | null | undefined;
                             })[];
                             chain: {
-                                Explorer: {
-                                    id: string;
-                                    type: import("@db/api").$Enums.ExplorerType;
-                                    url: string;
-                                    chainId: number;
-                                }[];
-                            } & {
                                 id: number;
                                 name: string;
                                 icon: string;
@@ -13291,13 +13270,6 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;
@@ -16750,13 +16722,6 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;

package/dist/src/factories/opportunityMetadata/implementations/Ajna.js

@@ -3,7 +3,7 @@ import { OpportunityAction } from "@db/api";
 export class AjnaMetadata {
     async build(computeChainId, params, subType) {
         try {
-            const [collateral, quote] = await TokenService.getManyOrCreate([
+            const [collateral, quote] = await TokenService.findManyOrCreate([
                 {
                     chainId: computeChainId,
                     address: params.collateralToken,

package/dist/src/factories/opportunityMetadata/implementations/Badger.js

@@ -3,7 +3,7 @@ import { OpportunityAction } from "@db/api";
 export class BadgerMetadata {
     async build(computeChainId, params) {
         try {
-            const [token] = await TokenService.getManyOrCreate([{ chainId: computeChainId, address: params.targetToken }]);
+            const [token] = await TokenService.findManyOrCreate([{ chainId: computeChainId, address: params.targetToken }]);
             if (!token)
                 throw new Error("Failed to fetch tokens");
             return {

package/dist/src/index.d.ts

@@ -408,13 +408,6 @@ declare const app: Elysia<"", false, {
                                 price?: number | null | undefined;
                             })[];
                             chain: {
-                                Explorer: {
-                                    id: string;
-                                    type: import("@db/api").$Enums.ExplorerType;
-                                    url: string;
-                                    chainId: number;
-                                }[];
-                            } & {
                                 id: number;
                                 name: string;
                                 icon: string;

package/dist/src/libs/campaigns/utils/getUniswapV4Pools.js

@@ -23,14 +23,16 @@ export async function getUniswapV4Pools() {
             log.info(`found ${storedPoolsPerChain.length} already stored pools on ${NETWORK_LABELS[chainId]}`);
             let fromBlock;
             if (storedPoolsPerChain.length > 0) {
-                fromBlock = Math.max(...storedPools.map(x => x.fetchAtBlock)) + 1;
+                fromBlock = Math.max(...storedPoolsPerChain.map(x => x.fetchAtBlock)) + 1;
             }
             else {
                 fromBlock = await getContractCreationBlock(poolManagerAddress, jsonRPCprovider);
             }
             const toBlock = await jsonRPCprovider.getBlockNumber();
             const logs = await safeFetchLogs(chainId, // TODO: rm type enforcing
-            [UniswapV4PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock);
+            [UniswapV4PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock
+            // fromBlock + 10_000
+            );
             const decodedPools = await Promise.all(logs.map(async (log) => {
                 const [id, currency0, currency1, fee, tickSpacing, hooks] = UniswapV4PoolManagerInterface.decodeEventLog("Initialize", log.data, log.topics);
                 // Respect typing
@@ -78,6 +80,9 @@ export async function getUniswapV4Pools() {
                 if (pool.currency0 !== NULL_ADDRESS) {
                     try {
                         symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index].returnData)[0];
+                        if (symbolCurrency0.includes("/") || symbolCurrency0.includes("\u0000")) {
+                            symbolCurrency0 = "INVALID";
+                        }
                         decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 1].returnData)[0];
                     }
                     catch {
@@ -94,6 +99,9 @@ export async function getUniswapV4Pools() {
                 if (pool.currency1 !== NULL_ADDRESS) {
                     try {
                         symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index + 2].returnData)[0];
+                        if (symbolCurrency1.includes("/") || symbolCurrency1.includes("\u0000")) {
+                            symbolCurrency1 = "INVALID";
+                        }
                         decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 3].returnData)[0];
                     }
                     catch {
@@ -135,24 +143,27 @@ export async function getUniswapV4Pools() {
     });
     // Update the API database
     const tableData = Object.values(pools).flatMap(pools => Object.values(pools));
-    if (Object.values(pools).length > 0) {
-        try {
-            await apiDbClient.logged.createMany({
-                data: tableData.map(pool => ({
-                    fetchAtBlock: pool.fetchedAtBlock,
-                    caughtFromAddress: UniswapV4Addresses[pool.chainId]?.PoolManager ?? NULL_ADDRESS,
-                    chainId: pool.chainId,
-                    entityData: pool,
-                    id: Bun.hash(`${pool.poolId}-${pool.chainId}`).toString(),
-                    type: LoggedEntityType.UNISWAP_V4,
-                })),
-            });
-            log.info("✅ successfully saved vaults to API database (`Logged` table)");
-            // }
-        }
-        catch (e) {
-            log.error("getUniswapV4Pools/LoggedTableUpdate", e);
-            throw new Error("Error while saving UniV4 pools to API database (`Logged` table)");
+    for (const chainId of UNIV4_CHAINIDS) {
+        if (tableData.filter(p => p.chainId === chainId).length > 0) {
+            try {
+                await apiDbClient.logged.createMany({
+                    data: tableData
+                        .filter(point => point.chainId === chainId)
+                        .map(pool => ({
+                        fetchAtBlock: pool.fetchedAtBlock,
+                        caughtFromAddress: UniswapV4Addresses[pool.chainId]?.PoolManager ?? NULL_ADDRESS,
+                        chainId: pool.chainId,
+                        entityData: pool,
+                        id: Bun.hash(`${pool.poolId}-${pool.chainId}`).toString(),
+                        type: LoggedEntityType.UNISWAP_V4,
+                    })),
+                });
+                log.info(`✅ successfully saved vaults to API database ('Logged' table) on ${NETWORK_LABELS[chainId]}`);
+            }
+            catch (e) {
+                log.error("getUniswapV4Pools/LoggedTableUpdate", e);
+                throw new Error(`Error while saving UniV4 pools to API database ('Logged' table) on ${NETWORK_LABELS[chainId]}`);
+            }
         }
     }
     log.info(`✅ successfully fetched ${tableData.length} new pool(s) on UniswapV4`);

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

@@ -183,7 +183,7 @@ export class CampaignRepository {
     static async upsert(campaign) {
         const campaignType = CampaignService.getTypeFromV3(campaign.type);
         try {
-            const [rewardToken] = await TokenService.getManyOrCreate([
+            const [rewardToken] = await TokenService.findManyOrCreate([
                 { chainId: campaign.chainId, address: campaign.rewardTokenAddress },
             ]);
             if (!rewardToken) {

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

@@ -51,8 +51,8 @@ export class EnsoService {
         return await Promise.all(route.map(async (r) => {
             switch (r.action) {
                 case "deposit": {
-                    const tokensIn = await TokenService.getManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
-                    const [tokenOut] = await TokenService.getManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
+                    const tokensIn = await TokenService.findManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
+                    const [tokenOut] = await TokenService.findManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
                     return {
                         action: "deposit",
                         tokens: tokensIn.filter(a => !!a),
@@ -60,8 +60,8 @@ export class EnsoService {
                     };
                 }
                 case "swap": {
-                    const [from] = await TokenService.getManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
-                    const [to] = await TokenService.getManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
+                    const [from] = await TokenService.findManyOrCreate(r.tokenIn.map(t => ({ address: t, chainId })));
+                    const [to] = await TokenService.findManyOrCreate(r.tokenOut.map(t => ({ address: t, chainId })));
                     return { action: "swap", from: from, to: to };
                 }
             }
@@ -106,7 +106,7 @@ export class EnsoService {
                     amountIn: [fromTokenAmount.toString()],
                     slippage: options.slippage?.toString(),
                 });
-                const [LpToken] = await TokenService.getManyOrCreate([{ address: identifier, chainId }]);
+                const [LpToken] = await TokenService.findManyOrCreate([{ address: identifier, chainId }]);
                 const depositValue = await TokenService.getValue([{ ...LpToken, amount: BigInt(quote.amountOut) }]);
                 const actions = await EnsoService.getActions(chainId, quote.route, BigInt(quote.amountOut));
                 return { transaction: tx, depositValue: depositValue, actions };

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

@@ -54,7 +54,7 @@ export class KyberZapService {
         const actions = [];
         const processors = {
             ACTION_TYPE_PROTOCOL_FEE: async ({ protocolFee: { tokens: zapTokens } }) => {
-                const tokens = await TokenService.getManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
+                const tokens = await TokenService.findManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
                 return [
                     {
                         action: "fee",
@@ -65,7 +65,7 @@ export class KyberZapService {
             ACTION_TYPE_AGGREGATOR_SWAP: async ({ aggregatorSwap: { swaps } }) => {
                 const swapActions = [];
                 for (const { tokenIn, tokenOut } of swaps) {
-                    const [from, to] = await TokenService.getManyOrCreate([
+                    const [from, to] = await TokenService.findManyOrCreate([
                         { address: tokenIn.address, chainId },
                         { address: tokenOut.address, chainId },
                     ]);
@@ -80,7 +80,7 @@ export class KyberZapService {
             ACTION_TYPE_POOL_SWAP: async ({ poolSwap: { swaps } }) => {
                 const swapActions = [];
                 for (const { tokenIn, tokenOut } of swaps) {
-                    const [from, to] = await TokenService.getManyOrCreate([
+                    const [from, to] = await TokenService.findManyOrCreate([
                         { address: tokenIn.address, chainId },
                         { address: tokenOut.address, chainId },
                     ]);
@@ -93,7 +93,7 @@ export class KyberZapService {
                 return swapActions;
             },
             ACTION_TYPE_ADD_LIQUIDITY: async ({ addLiquidity: { tokens: zapTokens } }) => {
-                const tokens = await TokenService.getManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
+                const tokens = await TokenService.findManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
                 return [
                     {
                         action: "deposit",
@@ -124,7 +124,7 @@ export class KyberZapService {
             chainId,
         });
         const actions = await KyberZapService.getActions(chainId, route.zapDetails.actions);
-        const [tokenIn] = await TokenService.getManyOrCreate([{ address: fromTokenAddress, chainId }]);
+        const [tokenIn] = await TokenService.findManyOrCreate([{ address: fromTokenAddress, chainId }]);
         const deposit = actions.findLast(({ action }) => action === "deposit");
         const tokenInValue = await TokenService.getValue([{ ...tokenIn, amount: fromTokenAmount }]);
         const depositValue = await TokenService.getValue(deposit.tokens);

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

@@ -263,13 +263,6 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                             price?: number | null | undefined;
                         })[];
                         chain: {
-                            Explorer: {
-                                id: string;
-                                type: import("@db/api").$Enums.ExplorerType;
-                                url: string;
-                                chainId: number;
-                            }[];
-                        } & {
                             id: number;
                             name: string;
                             icon: string;

package/dist/src/modules/v4/opportunity/opportunity.repository.d.ts

@@ -175,13 +175,6 @@ export declare abstract class OpportunityRepository {
     }) | null>;
     static findUniqueOrThrow(id: string, withTest?: boolean, withCampaigns?: boolean): Promise<{
         Chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;

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

@@ -551,13 +551,6 @@ export declare abstract class OpportunityService {
             price?: number | null | undefined;
         })[];
         chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;
@@ -723,13 +716,6 @@ export declare abstract class OpportunityService {
             price?: number | null | undefined;
         })[];
         chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;
@@ -891,13 +877,6 @@ export declare abstract class OpportunityService {
             price?: number | null | undefined;
         })[];
         chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;
@@ -938,13 +917,6 @@ export declare abstract class OpportunityService {
             price?: number | null | undefined;
         })[];
         chain: {
-            Explorer: {
-                id: string;
-                type: import("@db/api").$Enums.ExplorerType;
-                url: string;
-                chainId: number;
-            }[];
-        } & {
             id: number;
             name: string;
             icon: string;

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

@@ -69,7 +69,7 @@ export class OpportunityService {
             identifier: campaign.opportunityIdentifier,
             type: campaignType,
         });
-        const tokens = (await TokenService.getManyOrCreate(metadata.tokens)).filter(t => t !== undefined);
+        const tokens = (await TokenService.findManyOrCreate(metadata.tokens)).filter(t => t !== undefined);
         const params = JSON.parse(campaign.params);
         const now = moment().unix();
         const opportunity = {

package/dist/src/modules/v4/price/price.repository.js

@@ -6,7 +6,7 @@ export class PriceRepository {
     static async findManyPriceSources(query) {
         return await apiDbClient.priceSource.findMany({
             where: {
-                method: query.method ?? undefined,
+                method: query?.method ?? undefined,
             },
         });
     }

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

@@ -321,7 +321,7 @@ export class RewardService {
                     token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
                 }
                 catch {
-                    await TokenService.create(await TokenService.fetchOnChain({ address: rewardToken, chainId }));
+                    await TokenService.findManyOrCreate([{ address: rewardToken, chainId }]);
                     token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
                 }
                 const campaignDailyValue = await TokenService.getValueByTokenId(tokenToAmount);

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

@@ -278,13 +278,6 @@ export declare const v4: Elysia<"/v4", false, {
                                 price?: number | null | undefined;
                             })[];
                             chain: {
-                                Explorer: {
-                                    id: string;
-                                    type: import("@db/api").$Enums.ExplorerType;
-                                    url: string;
-                                    chainId: number;
-                                }[];
-                            } & {
                                 id: number;
                                 name: string;
                                 icon: string;

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

@@ -77,6 +77,8 @@ export declare abstract class TokenRepository {
      * @param chainId
      */
     static updateAddressPrices(address: string, price: number, chainId?: number): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    static updateMissingIconsPerSymbol(symbol: string, icon: string): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    static fetchIconFromCoingeckoTicker(coingeckoTicker: string): Promise<any>;
     static findChains(): Promise<Record<string, ChainId>>;
     /**
      * create a token on database

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

@@ -2,6 +2,7 @@ import { getTokenInfo } from "@/libs/tokens/tokenInfo";
 import { executeSimple } from "@/utils/execute";
 import { apiDbClient } from "@/utils/prisma";
 import { NETWORK_LABELS } from "@sdk";
+import axios from "axios";
 export class TokenRepository {
     static #transformQueryToPrismaFilters(query) {
         const ids = query.id ? query.id.map(id => ({ id })) : [];
@@ -129,6 +130,18 @@ export class TokenRepository {
             },
         });
     }
+    static async updateMissingIconsPerSymbol(symbol, icon) {
+        return await apiDbClient.token.updateMany({
+            data: { icon },
+            where: {
+                symbol: symbol,
+                icon: "",
+            },
+        });
+    }
+    static async fetchIconFromCoingeckoTicker(coingeckoTicker) {
+        return (await axios.get(`https://api.coingecko.com/api/v3/coins/${coingeckoTicker}`)).data.image.small;
+    }
     static async findChains() {
         const tokens = await apiDbClient.token.findMany({
             select: { chainId: true, id: true },

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type ChainId } from "@sdk";
-import type { NotionWebhookModel } from "./token.model";
-import type { CreateTokenModel, GetTokenQueryModel, Token, TokenModel, TokenUnique, UpdateTokenModel } from "./token.model";
+import type { CreateTokenModel, NotionWebhookModel } from "./token.model";
+import type { GetTokenQueryModel, Token, TokenModel, TokenUnique, UpdateTokenModel } from "./token.model";
 import { TokenRepository } from "./token.repository";
 export declare abstract class TokenService {
     static hashId(token: TokenUnique): string;
@@ -92,44 +92,6 @@ export declare abstract class TokenService {
      * @param excludeAddresses to not update symbols that defined using addresses
      */
     static updatePrices(pricer: Pricer): Promise<void>;
-    /**
-     * Create token on database
-     * @param chainId
-     * @param address
-     */
-    static create(token: Omit<Token["model"], "id">): Promise<({
-        symbol: string;
-        id: string;
-        name: string | null;
-        icon: string;
-        chainId: number;
-        address: string;
-        decimals: number;
-        verified: boolean;
-        isTest: boolean;
-        isNative: boolean;
-    } & {
-        price?: number | null | undefined;
-    }) | undefined>;
-    /**
-     * Fetches symbol, address, decimals and creates token on database
-     * @param chainId
-     * @param address
-     */
-    static fillAndCreate(token: CreateTokenModel): Promise<({
-        symbol: string;
-        id: string;
-        name: string | null;
-        icon: string;
-        chainId: number;
-        address: string;
-        decimals: number;
-        verified: boolean;
-        isTest: boolean;
-        isNative: boolean;
-    } & {
-        price?: number | null | undefined;
-    }) | undefined>;
     /**
      * Read token from database
      * @param chainId
@@ -206,7 +168,7 @@ export declare abstract class TokenService {
      * @param chainId
      * @param address
      */
-    static getManyOrCreate(tokens: TokenModel[]): Promise<(Token["model"] | undefined)[]>;
+    static findManyOrCreate(tokens: TokenModel[]): Promise<(Token["model"] | undefined)[]>;
     static getValidRewardTokens(chainId: number): Promise<{
         minimumAmountPerHour: any;
         symbol: string;
@@ -251,9 +213,28 @@ export declare abstract class TokenService {
         price: number | null;
     }>;
     /**
+     * Fetches symbol, address, decimals and creates token on database
+     * @param chainId
+     * @param address
+     */
+    static fillAndCreate(token: CreateTokenModel): Promise<({
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        chainId: number;
+        address: string;
+        decimals: number;
+        verified: boolean;
+        isTest: boolean;
+        isNative: boolean;
+    } & {
+        price?: number | null | undefined;
+    }) | undefined>;
+    /**
+     * @deprecated Should be useless now that the token list is not used anymore
      * Get all tokens from https://github.com/AngleProtocol/angle-token-list and override icons from it
      * TODO: use the bucket
-     * @deprecated Should be useless now that the token list is not used anymore
      */
     static fillTokenAndIconsFromTokenList(): Promise<void>;
 }