@merkl/api 0.20.51 → 0.20.53

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

@@ -1,6 +1,32 @@
 import type { apiDbClient } from "@db";
 import type { Prisma } from "@db/api";
-import type { MerklChainId, UniswapV4PoolType } from "@sdk";
+import { type MerklChainId, type UniswapV4PoolType } from "@sdk";
+export declare const UniV4ChainIdArray: MerklChainId[];
+export declare enum LoggedEntityType {
+    EULER = "EULER_VAULT",
+    UNISWAP_V4 = "UNISWAP_V4"
+}
+export type UniV4ChainId = (typeof UniV4ChainIdArray)[number];
+export type UniswapV4PoolsReturnType = {
+    [chainId in MerklChainId]?: {
+        [poolId: string]: UniswapV4PoolType;
+    };
+};
+export type LoggedCreateBody = Prisma.Args<typeof apiDbClient.logged, "createMany">["data"];
+export declare const UniswapV4PoolDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    currency0: import("@sinclair/typebox").TString;
+    currency1: import("@sinclair/typebox").TString;
+    decimalsCurrency0: import("@sinclair/typebox").TNumber;
+    decimalsCurrency1: import("@sinclair/typebox").TNumber;
+    hooks: import("@sinclair/typebox").TString;
+    fetchedAtBlock: import("@sinclair/typebox").TNumber;
+    lpFee: import("@sinclair/typebox").TNumber;
+    poolId: import("@sinclair/typebox").TString;
+    symbolCurrency0: import("@sinclair/typebox").TString;
+    symbolCurrency1: import("@sinclair/typebox").TString;
+    tickSpacing: import("@sinclair/typebox").TNumber;
+}>;
 export declare const Bytes32Dto: import("@sinclair/typebox").TObject<{
     poolId: import("@sinclair/typebox").TRegExp;
 }>;
@@ -10,24 +36,17 @@ export declare const RewardsPerV3PositionDto: import("@sinclair/typebox").TObjec
     positionId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 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;
-        currency1: import("@sinclair/typebox").TString;
-        fee: import("@sinclair/typebox").TNumber;
-        tickSpacing: import("@sinclair/typebox").TNumber;
-        hooks: import("@sinclair/typebox").TString;
-    }>;
-    poolId: import("@sinclair/typebox").TString;
+    chainId: import("@sinclair/typebox").TNumber;
+    currency0: import("@sinclair/typebox").TString;
+    currency1: import("@sinclair/typebox").TString;
     decimalsCurrency0: import("@sinclair/typebox").TNumber;
     decimalsCurrency1: import("@sinclair/typebox").TNumber;
+    hooks: import("@sinclair/typebox").TString;
+    fetchedAtBlock: import("@sinclair/typebox").TNumber;
+    lpFee: import("@sinclair/typebox").TNumber;
+    poolId: import("@sinclair/typebox").TString;
     symbolCurrency0: import("@sinclair/typebox").TString;
     symbolCurrency1: import("@sinclair/typebox").TString;
+    tickSpacing: import("@sinclair/typebox").TNumber;
 }>>;
-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"];
 export type RewardsPerPositionModel = typeof RewardsPerV3PositionDto.static;

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

@@ -1,18 +1,32 @@
+import { UniswapV4Addresses } from "@sdk";
 import { t } from "elysia";
-const UniswapV4PoolKeyDto = t.Object({
+export const UniV4ChainIdArray = Object.keys(UniswapV4Addresses).map((x) => Number(x));
+export var LoggedEntityType;
+(function (LoggedEntityType) {
+    LoggedEntityType["EULER"] = "EULER_VAULT";
+    LoggedEntityType["UNISWAP_V4"] = "UNISWAP_V4";
+})(LoggedEntityType || (LoggedEntityType = {}));
+// DTOs
+// const UniswapV4PoolKeyDto = t.Object({
+//   currency0: t.String(),
+//   currency1: t.String(),
+//   fee: t.Numeric(),
+//   tickSpacing: t.Numeric(),
+//   hooks: t.String(),
+// });
+export const UniswapV4PoolDto = t.Object({
+    chainId: t.Numeric(), // Assuming MerklChainId is a numeric type
     currency0: t.String(),
     currency1: t.String(),
-    fee: t.Numeric(),
-    tickSpacing: t.Numeric(),
-    hooks: t.String(),
-});
-const UniswapV4PoolDto = t.Object({
-    poolKey: UniswapV4PoolKeyDto,
-    poolId: t.String(),
     decimalsCurrency0: t.Numeric(),
     decimalsCurrency1: t.Numeric(),
+    hooks: t.String(),
+    fetchedAtBlock: t.Numeric(),
+    lpFee: t.Numeric(),
+    poolId: t.String(),
     symbolCurrency0: t.String(),
     symbolCurrency1: t.String(),
+    tickSpacing: t.Numeric(),
 });
 export const Bytes32Dto = t.Object({
     poolId: t.RegExp(/^0x[a-fA-F0-9]{64}$/, {

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

@@ -1,6 +1,6 @@
-import type { LoggedCreateBody } from "./uniswap.model";
+import type { LoggedCreateBody, UniV4ChainId } from "./uniswap.model";
 export declare abstract class UniswapRepository {
-    static getStoredPools(): Promise<{
+    static getStoredUniswapV4Pools(chainId?: UniV4ChainId): Promise<{
         id: string;
         type: import("@db/api").$Enums.LoggedEntityType;
         address: string | null;

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

@@ -1,9 +1,9 @@
 import { apiDbClient } from "@db";
 import { LoggedEntityType } from "@db/api";
 export class UniswapRepository {
-    static async getStoredPools() {
+    static async getStoredUniswapV4Pools(chainId) {
         return await apiDbClient.logged.findMany({
-            where: { type: LoggedEntityType.UNISWAP_V4 },
+            where: { type: LoggedEntityType.UNISWAP_V4, ...(!!chainId && { chainId: chainId }) },
         });
     }
     static async createMany(data) {

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

@@ -1,23 +1,8 @@
 import { type MerklChainId } from "@sdk";
-import type { RewardsPerPositionModel, UniswapV4PoolsReturnType } from "./uniswap.model";
-export declare const PoolManagerInterface: any;
+import { type RewardsPerPositionModel, type UniV4ChainId, type UniswapV4PoolsReturnType } from "./uniswap.model";
 export declare abstract class UniswapService {
     static findV3RewardsPerPosition(query: RewardsPerPositionModel): Promise<Record<string, Record<string, any[]>>>;
-    static getPoolsByChain(chainId: MerklChainId): Promise<{
-        [x: string]: {
-            poolId: string;
-            poolKey: {
-                hooks: string;
-                fee: number;
-                tickSpacing: number;
-                currency0: string;
-                currency1: string;
-            };
-            decimalsCurrency0: number;
-            decimalsCurrency1: number;
-            symbolCurrency0: string;
-            symbolCurrency1: string;
-        };
-    }>;
-    static getPools(): Promise<UniswapV4PoolsReturnType>;
+    static getUniswapV4Pools(chainId?: UniV4ChainId): Promise<UniswapV4PoolsReturnType>;
+    /** @deprecated */
+    static getUniswapV4PoolsForChain(chainId: MerklChainId): Promise<UniswapV4PoolsReturnType>;
 }

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

@@ -1,18 +1,15 @@
 import { safeFetchLogs } from "@/engine/dynamicData/utils/fetchLogs";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
 import { log } from "@/utils/logger";
 import { providers } from "@/utils/providers";
-import { LoggedEntityType } from "@db/api";
-import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, UniswapV4PoolManager__factory, getContractCreationBlock, } from "@sdk";
-import { utils } from "ethers";
+import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, getContractCreationBlock, } from "@sdk";
 import { getAddress } from "viem";
 import { BlacklistService } from "../blacklist";
 import { ChainService } from "../chain/chain.service";
 import { MerklRootService } from "../merklRoot";
 import { OpportunityService } from "../opportunity";
 import { RewardService } from "../reward";
+import { LoggedEntityType, UniV4ChainIdArray, } from "./uniswap.model";
 import { UniswapRepository } from "./uniswap.repository";
-export const PoolManagerInterface = UniswapV4PoolManager__factory.createInterface();
 export class UniswapService {
     static async findV3RewardsPerPosition(query) {
         /** Check if the user is blacklisted */
@@ -52,83 +49,24 @@ export class UniswapService {
         }
         return res;
     }
-    static async getPoolsByChain(chainId) {
-        const lastBlock = await providers[chainId].getBlockNumber();
-        const logs = await safeFetchLogs(chainId, [PoolManagerInterface.getEventTopic("Initialize")], ["0xE8E23e97Fa135823143d6b9Cba9c699040D51F70"], 0, lastBlock);
-        const poolData = [];
-        const calls = [];
-        for (const log of logs) {
-            const poolId = utils.defaultAbiCoder.decode(["bytes32"], log.topics[1])[0];
-            const currency0 = utils.defaultAbiCoder.decode(["address"], log.topics[2])[0];
-            const currency1 = utils.defaultAbiCoder.decode(["address"], log.topics[3])[0];
-            const [_indexedPoolId, _indexedCurrency0, _indexedCurrency1, fee, tickSpacing, hooks, sqrtPriceX98, tick] = PoolManagerInterface.decodeEventLog("Initialize", log.data, log.topics);
-            poolData.push({
-                poolId,
-                poolKey: {
-                    currency0,
-                    currency1,
-                    fee,
-                    tickSpacing,
-                    hooks,
-                },
-            });
-            calls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("symbol"),
-                target: currency0,
-            }, {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("decimals"),
-                target: currency0,
-            }, {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("symbol"),
-                target: currency1,
-            }, {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("decimals"),
-                target: currency1,
-            });
+    static async getUniswapV4Pools(chainId) {
+        let chainIdArray;
+        if (!!chainId) {
+            chainIdArray = [chainId];
         }
-        const result = await batchMulticallCallWithRetry(chainId, { calls });
-        const res = {};
-        for (const [index, pool] of poolData.entries()) {
-            let symbolCurrency0 = "";
-            let decimalsCurrency0 = 0;
-            let symbolCurrency1 = "";
-            let decimalsCurrency1 = 0;
-            try {
-                symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", result[index * 4].returnData)[0];
-            }
-            catch { }
-            try {
-                decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", result[index * 4 + 1].returnData)[0];
-            }
-            catch { }
-            try {
-                symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", result[index * 4 + 2].returnData)[0];
-            }
-            catch { }
-            try {
-                decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", result[index * 4 + 3].returnData)[0];
-            }
-            catch { }
-            res[pool.poolId] = { ...pool, symbolCurrency0, decimalsCurrency0, symbolCurrency1, decimalsCurrency1 };
+        else {
+            chainIdArray = UniV4ChainIdArray;
         }
-        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 UniswapRepository.getStoredPools();
-        const res = await Promise.all(UNIV4_CHAINIDS.map(async (chainId) => {
+        // 0_ Fetch all univ4 pools from API database
+        const storedPools = await UniswapRepository.getStoredUniswapV4Pools(chainId);
+        const res = await Promise.all(chainIdArray.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
+                // 1_ Get latest uniswapV4 pools for `chainId`
                 const storedPoolsPerChain = storedPools.filter(pool => pool.chainId === chainId);
                 log.info(`found ${storedPoolsPerChain.length} already stored pools on ${NETWORK_LABELS[chainId]}`);
                 let fromBlock;
@@ -140,12 +78,10 @@ export class UniswapService {
                 }
                 const toBlock = await jsonRPCprovider.getBlockNumber();
                 const logs = await safeFetchLogs(chainId, // TODO: rm type enforcing
-                [UniswapV4PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock
-                // fromBlock + 10_000
-                );
+                [UniswapV4PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock);
                 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
+                    // Match typing
                     return {
                         poolId: id,
                         chainId: chainId,
@@ -247,13 +183,13 @@ export class UniswapService {
             }
             return perChainIdRes;
         }));
-        UNIV4_CHAINIDS.forEach((chainId, i) => {
+        chainIdArray.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) {
+        for (const chainId of chainIdArray) {
             if (tableData.filter(p => p.chainId === chainId).length > 0) {
                 try {
                     await UniswapRepository.createMany(tableData
@@ -288,4 +224,8 @@ export class UniswapService {
         log.info("👋 exiting getUniswapV4Pools");
         return pools;
     }
+    /** @deprecated */
+    static async getUniswapV4PoolsForChain(chainId) {
+        return await UniswapService.getUniswapV4Pools(chainId);
+    }
 }

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

@@ -1,16 +1,16 @@
 import { Redis } from "@/cache";
-import { UniV4ChainIdArray, getUniswapV4Pools } from "@/engine/dynamicData/utils/getUniswapV4Pools";
 import { ChainUniqueDto } from "@/modules/v4/chain/chain.model";
-import { Bytes32Dto } from "@/modules/v4/uniswap/uniswap.model";
+import { Bytes32Dto, UniV4ChainIdArray } from "@/modules/v4/uniswap/uniswap.model";
+import { UniswapService } from "@/modules/v4/uniswap/uniswap.service";
 import { UnsupportedNetwork } from "@/utils/error";
 export default (app) => app.group("/uniswapv4", router => router
     .get("/", async () => {
-    return await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools);
+    return await Redis.getOrSet("UniswapV4Pools", UniswapService.getUniswapV4Pools);
 }, {
     tags: ["uniswapv4"],
 })
     .get("/:chainId", async ({ params }) => {
-    return (await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools, params.chainId))[params.chainId];
+    return (await Redis.getOrSet("UniswapV4Pools", UniswapService.getUniswapV4Pools, params.chainId))[params.chainId];
 }, {
     params: ChainUniqueDto,
     beforeHandle: ({ params }) => {
@@ -20,7 +20,7 @@ export default (app) => app.group("/uniswapv4", router => router
     tags: ["uniswapv4"],
 })
     .get("/pool/:poolId", async ({ params }) => {
-    return Object.values((await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools)))
+    return Object.values((await Redis.getOrSet("UniswapV4Pools", UniswapService.getUniswapV4Pools)))
         .flatMap(x => (x ? Object.values(x) : []))
         .filter(p => p.poolId === params.poolId);
 }, {

package/dist/src/utils/decodeCalls.js

@@ -1,5 +1,6 @@
 import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
 import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerV3StablePoolInterface, BalancerVaultInterface, BeefyInterface, BunniV2HubInterface, BunniV2TokenInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveLPTokenInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, ERC4626Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, HourglassERC20TBTInterface, HourglassVedaLockDepositorV2Interface, IonicInterface, LPManagerHelperInterface, LPManagerInterface, LayerBankERC20Interface, LayerBankInterface, LendleInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxInterface, RswEthStrategyInterface, SpectraYTInterface, SturdyInterface, SymetricAmbientStrategyInterface, SyncSwapClassicPoolInterface, TorosInterface, UniswapV2PoolInterface, UniswapV3PoolInterface, VePufferInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
+import { BigNumber } from "ethers";
 export function decodeCall(calls, index, key, type) {
     const returnData = calls[index];
     return decodeReturnValue(returnData, key, type);
@@ -135,6 +136,8 @@ export function decodeReturnValue(returnData, key, type) {
                     return EulerInterface.decodeFunctionResult("asset", returnData)[0];
                 case tokenType.hourglass:
                     return HourglassVedaLockDepositorV2Interface.decodeFunctionResult("getUnderlying", returnData)[0];
+                case tokenType.curve_gauge:
+                    return BalancerGaugeInterface.decodeFunctionResult("lp_token", returnData)[0];
                 default:
                     throw new Error(`Need tokenType for this key ${key}, or type ${type} not matched`);
             }
@@ -166,6 +169,7 @@ export function decodeReturnValue(returnData, key, type) {
         case "lp_price":
             switch (type) {
                 case tokenType.curve:
+                case tokenType.curve_gauge:
                     return CurveInterface.decodeFunctionResult("lp_price", returnData)[0];
                 case tokenType.curve_2:
                 case tokenType.maha:
@@ -233,7 +237,12 @@ export function decodeReturnValue(returnData, key, type) {
                 BalancerVaultInterface.decodeFunctionResult("getPoolTokens", returnData)[1],
             ];
         case "convertToAssets":
-            return FluidInterface.decodeFunctionResult("convertToAssets", returnData)[0];
+            switch (type) {
+                case tokenType.curve_gauge:
+                    return BigNumber.from("1000000000000000000");
+                default:
+                    return FluidInterface.decodeFunctionResult("convertToAssets", returnData)[0];
+            }
         case "tokenPrice":
             return TorosInterface.decodeFunctionResult("tokenPrice", returnData)[0];
         case "readTokens0":

package/dist/src/utils/encodeCalls.js

@@ -23,6 +23,7 @@ export function createCall(target, key, type, metaData) {
         case "lp_price":
             switch (type) {
                 case tokenType.curve:
+                case tokenType.curve_gauge:
                     return { allowFailure: true, callData: CurveInterface.encodeFunctionData("lp_price"), target };
                 case tokenType.curve_2:
                 case tokenType.maha:
@@ -114,6 +115,8 @@ export function createCall(target, key, type, metaData) {
                         callData: EulerInterface.encodeFunctionData("asset"),
                         target,
                     };
+                case tokenType.curve_gauge:
+                    return { allowFailure: true, callData: BalancerGaugeInterface.encodeFunctionData("lp_token"), target };
                 case tokenType.fraxlend:
                 case tokenType.sturdy_aggregator:
                 case tokenType.sturdy_silo:

package/dist/src/utils/generateCardName.js

@@ -134,6 +134,11 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""], displ
             return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}-${typeInfo.symbolToken2}`;
         case tokenType.maha:
             return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} LP on ${capitalize(typeInfo.protocol)}`;
+        case tokenType.curve_gauge:
+            if (!!typeInfo.symbolToken2) {
+                return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}-${typeInfo.symbolToken2} LP on ${capitalize(typeInfo.protocol)}`;
+            }
+            return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} LP on ${capitalize(typeInfo.protocol)}`;
         case tokenType.tempest:
         case tokenType.tempestStaking:
             return `Deposit into ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} vault on ${capitalize(typeInfo.protocol)}`;