@merkl/api 0.18.13 → 0.19.0

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

@@ -137,6 +137,7 @@ export declare const v4: Elysia<"/v4", false, {
                         chainId?: string | undefined;
                         mainProtocolId?: string | undefined;
                         campaigns?: boolean | undefined;
+                        rewardTokenSymbol?: string | undefined;
                         order?: string | undefined;
                         test?: boolean | undefined;
                         minimumTvl?: number | undefined;
@@ -329,6 +330,7 @@ export declare const v4: Elysia<"/v4", false, {
                         chainId?: string | undefined;
                         mainProtocolId?: string | undefined;
                         campaigns?: boolean | undefined;
+                        rewardTokenSymbol?: string | undefined;
                         order?: string | undefined;
                         test?: boolean | undefined;
                         minimumTvl?: number | undefined;
@@ -816,6 +818,7 @@ export declare const v4: Elysia<"/v4", false, {
                             chainId?: string | undefined;
                             mainProtocolId?: string | undefined;
                             campaigns?: boolean | undefined;
+                            rewardTokenSymbol?: string | undefined;
                             order?: string | undefined;
                             test?: boolean | undefined;
                             minimumTvl?: number | undefined;
@@ -855,6 +858,7 @@ export declare const v4: Elysia<"/v4", false, {
                                 chainId?: string | undefined;
                                 mainProtocolId?: string | undefined;
                                 campaigns?: boolean | undefined;
+                                rewardTokenSymbol?: string | undefined;
                                 order?: string | undefined;
                                 test?: boolean | undefined;
                                 minimumTvl?: number | undefined;
@@ -895,6 +899,7 @@ export declare const v4: Elysia<"/v4", false, {
                                 chainId?: string | undefined;
                                 mainProtocolId?: string | undefined;
                                 campaigns?: boolean | undefined;
+                                rewardTokenSymbol?: string | undefined;
                                 order?: string | undefined;
                                 test?: boolean | undefined;
                                 minimumTvl?: number | undefined;

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

@@ -98,8 +98,10 @@ export class StatusService {
         const res = {};
         for (const [index, chainIdString] of Object.keys(merklRoots).entries()) {
             const chainId = Number.parseInt(chainIdString);
-            const delayedCampaigns = delayedCampaignArray[index].status === "rejected" ? [] : delayedCampaignArray[index].value;
-            const liveCampaigns = liveCampaignArray[index].status === "rejected" ? 0 : liveCampaignArray[index].value;
+            const delayedCampaignResult = delayedCampaignArray[index];
+            const liveCampaignResult = liveCampaignArray[index];
+            const delayedCampaigns = delayedCampaignResult.status === "rejected" ? [] : delayedCampaignResult.value;
+            const liveCampaigns = liveCampaignResult.status === "rejected" ? 0 : liveCampaignResult.value;
             if (!registry(chainId)?.Merkl?.DistributionCreator || !registry(chainId)?.Merkl?.Distributor) {
                 log.warn(`Missing registry for ${NETWORK_LABELS[chainId]}`);
                 continue;

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

@@ -76,7 +76,15 @@ export class TokenService {
             chainId: token.chainId,
             address: token.address,
             icon: "",
-            ...Object.assign({ name: "unknown", decimals: 18, symbol: "UNKNOWN", verified: false, isTest: false, isNative: false }, onchainData),
+            ...Object.assign({
+                name: "unknown",
+                decimals: 18,
+                symbol: "UNKNOWN",
+                verified: false,
+                isTest: false,
+                isPoint: false,
+                isNative: false,
+            }, onchainData),
         };
     }
     static async tryToFillWithCoingeckoIcons() {
@@ -344,6 +352,7 @@ export class TokenService {
                             decimals: token.decimals,
                             icon: token.logoURI,
                             isTest: false,
+                            isPoint: false,
                             isNative: false,
                         });
                         log.local(`Token created: ${res?.symbol} on ${NETWORK_LABELS[Number.parseInt(chain)]}`);

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

@@ -1,3 +1,6 @@
+import type { apiDbClient } from "@db";
+import type { Prisma } from "@db/api";
+import type { MerklChainId, UniswapV4PoolType } from "@sdk";
 export declare const UniswapV4PoolsDto: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
     poolKey: import("@sinclair/typebox").TObject<{
         currency0: import("@sinclair/typebox").TString;
@@ -12,4 +15,10 @@ export declare const UniswapV4PoolsDto: import("@sinclair/typebox").TRecord<impo
     symbolCurrency0: import("@sinclair/typebox").TString;
     symbolCurrency1: import("@sinclair/typebox").TString;
 }>>;
+export type UniswapV4PoolsReturnType = {
+    [chainId in MerklChainId]?: {
+        [poolId: string]: UniswapV4PoolType;
+    };
+};
 export type UniswapV4PoolsEntity = typeof UniswapV4PoolsDto.static;
+export type LoggedCreateBody = Prisma.Args<typeof apiDbClient.logged, "createMany">["data"];

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

@@ -1,2 +1,13 @@
+import type { LoggedCreateBody } from "./uniswapV4.model";
 export declare abstract class UniswapV4Repository {
+    static getStoredPools(): Promise<{
+        id: string;
+        type: import("@db/api").$Enums.LoggedEntityType;
+        address: string | null;
+        chainId: number;
+        fetchAtBlock: number;
+        caughtFromAddress: string;
+        entityData: import("database/api/.generated/runtime/library").JsonValue;
+    }[]>;
+    static createMany(data: LoggedCreateBody): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
 }

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

@@ -1,2 +1,12 @@
+import { apiDbClient } from "@db";
+import { LoggedEntityType } from "@db/api";
 export class UniswapV4Repository {
+    static async getStoredPools() {
+        return await apiDbClient.logged.findMany({
+            where: { type: LoggedEntityType.UNISWAP_V4 },
+        });
+    }
+    static async createMany(data) {
+        return await apiDbClient.logged.createMany({ data });
+    }
 }

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

@@ -1,4 +1,5 @@
 import { type MerklChainId } from "@sdk";
+import type { UniswapV4PoolsReturnType } from "./uniswapV4.model";
 export declare const PoolManagerInterface: any;
 export declare abstract class UniswapV4Service {
     static getPoolsByChain(chainId: MerklChainId): Promise<{
@@ -17,4 +18,5 @@ export declare abstract class UniswapV4Service {
             symbolCurrency1: string;
         };
     }>;
+    static getPools(): Promise<UniswapV4PoolsReturnType>;
 }

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

@@ -1,8 +1,11 @@
 import { safeFetchLogs } from "@/libs/campaigns/utils/fetchLogs";
 import { batchMulticallCallWithRetry } from "@/utils/generic";
+import { log } from "@/utils/logger";
 import { providers } from "@/utils/providers";
-import { ERC20Interface, UniswapV4PoolManager__factory } from "@sdk";
+import { LoggedEntityType } from "@db/api";
+import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, UniswapV4PoolManager__factory, getContractCreationBlock, } from "@sdk";
 import { utils } from "ethers";
+import { UniswapV4Repository } from "./uniswapV4.repository";
 export const PoolManagerInterface = UniswapV4PoolManager__factory.createInterface();
 export class UniswapV4Service {
     static async getPoolsByChain(chainId) {
@@ -70,4 +73,175 @@ export class UniswapV4Service {
         }
         return res;
     }
+    static async getPools() {
+        const UNIV4_CHAINIDS = Object.keys(UniswapV4Addresses).map((x) => Number(x));
+        const pools = {};
+        // 0_ Fetch all euler vaults from database
+        const storedPools = await UniswapV4Repository.getStoredPools();
+        const res = await Promise.all(UNIV4_CHAINIDS.map(async (chainId) => {
+            chainId = chainId;
+            const perChainIdRes = {};
+            const poolManagerAddress = UniswapV4Addresses[chainId]?.PoolManager ?? NULL_ADDRESS;
+            const jsonRPCprovider = providers[chainId];
+            try {
+                // 1_ Get latest euler vaults from chain
+                const storedPoolsPerChain = storedPools.filter(pool => pool.chainId === chainId);
+                log.info(`found ${storedPoolsPerChain.length} already stored pools on ${NETWORK_LABELS[chainId]}`);
+                let fromBlock;
+                if (storedPoolsPerChain.length > 0) {
+                    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
+                // 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
+                    return {
+                        poolId: id,
+                        chainId: chainId,
+                        currency0: currency0,
+                        currency1: currency1,
+                        tickSpacing: tickSpacing,
+                        lpFee: fee,
+                        hooks: hooks,
+                        fetchedAtBlock: Number(log.blockNumber),
+                    };
+                }));
+                log.local(`fetched ${decodedPools.length} pool(s) on ${NETWORK_LABELS[chainId] ?? "Sepolia"} between blocks ${fromBlock} and ${toBlock}`);
+                /** Extra calls batch to get the collateral addresses */
+                const resCurrencies = await ChainInteractionService(chainId).fetchState(decodedPools.flatMap(pool => {
+                    return [
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("symbol"),
+                            target: pool.currency0,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("decimals"),
+                            target: pool.currency0,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("symbol"),
+                            target: pool.currency1,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("decimals"),
+                            target: pool.currency1,
+                        },
+                    ].filter(x => x.target !== NULL_ADDRESS);
+                }));
+                let index = 0;
+                for (const pool of decodedPools) {
+                    let symbolCurrency0 = "UNKNOWN";
+                    let decimalsCurrency0 = 18;
+                    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 {
+                            log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency0 ${pool.currency0} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                        }
+                    }
+                    else {
+                        symbolCurrency0 = "ETH";
+                        decimalsCurrency0 = 18;
+                        index -= 2;
+                    }
+                    let symbolCurrency1 = "UNKNOWN";
+                    let decimalsCurrency1 = 18;
+                    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 {
+                            log.error("getUniswapV4Pools", `issue when fetching symbol / decimals for currency1 ${pool.currency1} of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                        }
+                    }
+                    else {
+                        symbolCurrency1 = "ETH";
+                        decimalsCurrency1 = 18;
+                        index -= 2;
+                    }
+                    const id = pool.poolId;
+                    perChainIdRes[id ?? "unknownKey"] = {
+                        chainId: pool.chainId,
+                        currency0: pool.currency0,
+                        currency1: pool.currency1,
+                        decimalsCurrency0,
+                        decimalsCurrency1,
+                        hooks: pool.hooks,
+                        fetchedAtBlock: pool.fetchedAtBlock,
+                        lpFee: pool.lpFee,
+                        poolId: id,
+                        poolKey: pool.poolKey,
+                        symbolCurrency0,
+                        symbolCurrency1,
+                        tickSpacing: pool.tickSpacing,
+                    };
+                    index += 4;
+                }
+            }
+            catch (e) {
+                log.error(`issue when fetching UniswapV4 pools on ${NETWORK_LABELS[chainId]}`, e);
+            }
+            return perChainIdRes;
+        }));
+        UNIV4_CHAINIDS.forEach((chainId, i) => {
+            if (!!res[i])
+                pools[chainId] = res[i];
+        });
+        // Update the API database
+        const tableData = Object.values(pools).flatMap(pools => Object.values(pools));
+        for (const chainId of UNIV4_CHAINIDS) {
+            if (tableData.filter(p => p.chainId === chainId).length > 0) {
+                try {
+                    await UniswapV4Repository.createMany(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`);
+        // _ Merge previoulsy stored pools with newly fetched ones
+        // TODO optimize this part
+        if (storedPools.length > 0) {
+            for (const pool of storedPools) {
+                const chainId = pool.chainId;
+                if (!pools[chainId])
+                    pools[chainId] = {};
+                pools[chainId][pool.entityData.poolId] = pool.entityData;
+            }
+        }
+        log.info("👋 exiting getUniswapV4Pools");
+        return pools;
+    }
 }

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

@@ -26,7 +26,7 @@ export default class PriceService {
         });
     };
     async fetchPrices() {
-        const tokenPriceSources = await PriceSourceService.findManyPriceSources();
+        const tokenPriceSources = await PriceSourceService.findManyPriceSources({});
         /**
          * @description Factory pricer's call to get prices from different sources
          */

package/dist/src/utils/prices/services/erc4626Service.js

@@ -22,7 +22,7 @@ export default class ERC4626Service {
             return res;
         });
         const resolvedPrices = await Promise.all(pricePromises);
-        return resolvedPrices.flat().filter(price => price !== undefined);
+        return resolvedPrices.flat().filter(price => price !== undefined && price !== null);
     }
     async priceCalculation(rate, vaultToken) {
         try {

package/dist/src/utils/throw.d.ts

@@ -1,4 +1,21 @@
 import { type ChainId } from "@sdk";
+/**
+ * Use this function to throw an error if the address is invalid
+ * and normalize the address to its checksum version
+ *
+ * @dev Usage: params.address = throwOnInvalidAddress(params.address);
+ */
 export declare const throwOnInvalidRequiredAddress: (address: string) => string;
-export declare const throwOnInvalidAddress: (address: string) => string | undefined;
+/**
+ * Use this function to throw an error if the address is invalid
+ * and normalize the address to its checksum version
+ *
+ * Address can be null or undefined
+ *
+ * @dev Usage: params.address = throwOnInvalidAddress(params.address);
+ */
+export declare const throwOnInvalidAddress: (address: string | undefined) => string | undefined;
+/**
+ * Use this function to throw an error if the chainId is not supported by Merkl
+ */
 export declare const throwOnUnsupportedChainId: (chainId: ChainId) => void;

package/dist/src/utils/throw.js

@@ -1,6 +1,12 @@
 import { isSupportedChain } from "@sdk";
 import { utils } from "ethers";
 import { InvalidParameter, UnsupportedNetwork } from "./error";
+/**
+ * Use this function to throw an error if the address is invalid
+ * and normalize the address to its checksum version
+ *
+ * @dev Usage: params.address = throwOnInvalidAddress(params.address);
+ */
 export const throwOnInvalidRequiredAddress = (address) => {
     try {
         if (!address)
@@ -11,6 +17,14 @@ export const throwOnInvalidRequiredAddress = (address) => {
         throw new InvalidParameter(`Address ${address} is invalid`);
     }
 };
+/**
+ * Use this function to throw an error if the address is invalid
+ * and normalize the address to its checksum version
+ *
+ * Address can be null or undefined
+ *
+ * @dev Usage: params.address = throwOnInvalidAddress(params.address);
+ */
 export const throwOnInvalidAddress = (address) => {
     try {
         if (!address)
@@ -21,6 +35,9 @@ export const throwOnInvalidAddress = (address) => {
         throw new InvalidParameter(`Address ${address} is invalid`);
     }
 };
+/**
+ * Use this function to throw an error if the chainId is not supported by Merkl
+ */
 export const throwOnUnsupportedChainId = (chainId) => {
     if (chainId && !isSupportedChain(chainId, "merkl"))
         throw new UnsupportedNetwork(chainId);