@merkl/api 0.20.37 → 0.20.39

package/dist/src/modules/v4/{uniswapV4/uniswapV4.model.d.ts → uniswap/uniswap.model.d.ts}

@@ -4,6 +4,11 @@ import type { MerklChainId, UniswapV4PoolType } from "@sdk";
 export declare const Bytes32Dto: import("@sinclair/typebox").TObject<{
     poolId: import("@sinclair/typebox").TRegExp;
 }>;
+export declare const RewardsPerV3PositionDto: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    poolAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    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;
@@ -25,3 +30,4 @@ export type UniswapV4PoolsReturnType = {
 };
 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/{uniswapV4/uniswapV4.model.js → uniswap/uniswap.model.js}

@@ -19,4 +19,13 @@ export const Bytes32Dto = t.Object({
         description: "A 32-byte hexadecimal string (bytes32)",
     }),
 });
+export const RewardsPerV3PositionDto = t.Object({
+    address: t.String({ description: "Address of the rewarded user" }),
+    poolAddress: t.Optional(t.String({
+        description: "Address of the Uniswap pool. Default: returns rewards for all pools.",
+    })),
+    positionId: t.Optional(t.String({
+        description: "PositionId of the Uniswap position. Can be a tokenId if the position is an NFT or a bytes32 id if held directly on the pool. Default: returns rewards for all positions on the pools.",
+    })),
+});
 export const UniswapV4PoolsDto = t.Record(t.String(), UniswapV4PoolDto);

package/dist/src/modules/v4/{uniswapV4/uniswapV4.repository.d.ts → uniswap/uniswap.repository.d.ts}

@@ -1,5 +1,5 @@
-import type { LoggedCreateBody } from "./uniswapV4.model";
-export declare abstract class UniswapV4Repository {
+import type { LoggedCreateBody } from "./uniswap.model";
+export declare abstract class UniswapRepository {
     static getStoredPools(): Promise<{
         id: string;
         type: import("@db/api").$Enums.LoggedEntityType;

package/dist/src/modules/v4/{uniswapV4/uniswapV4.repository.js → uniswap/uniswap.repository.js}

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

package/dist/src/modules/v4/{uniswapV4/uniswapV4.service.d.ts → uniswap/uniswap.service.d.ts}

@@ -1,7 +1,8 @@
 import { type MerklChainId } from "@sdk";
-import type { UniswapV4PoolsReturnType } from "./uniswapV4.model";
+import type { RewardsPerPositionModel, UniswapV4PoolsReturnType } from "./uniswap.model";
 export declare const PoolManagerInterface: any;
-export declare abstract class UniswapV4Service {
+export declare abstract class UniswapService {
+    static findV3RewardsPerPosition(query: RewardsPerPositionModel): Promise<Record<string, Record<string, any[]>>>;
     static getPoolsByChain(chainId: MerklChainId): Promise<{
         [x: string]: {
             poolId: string;

package/dist/src/modules/v4/{uniswapV4/uniswapV4.service.js → uniswap/uniswap.service.js}

@@ -5,9 +5,53 @@ 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 { UniswapV4Repository } from "./uniswapV4.repository";
+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 { UniswapRepository } from "./uniswap.repository";
 export const PoolManagerInterface = UniswapV4PoolManager__factory.createInterface();
-export class UniswapV4Service {
+export class UniswapService {
+    static async findV3RewardsPerPosition(query) {
+        /** Check if the user is blacklisted */
+        const isBlacklisted = !!(await BlacklistService.isBlacklisted(query.address));
+        // pool address => NFT or Position ID => [rewards]
+        const res = {};
+        if (isBlacklisted)
+            return res;
+        const chains = await ChainService.findMany({});
+        const chainIds = chains.map(({ id }) => id);
+        /** Fetch current Merkle Roots */
+        const merkleRootsPromises = await Promise.allSettled(chainIds.map(chainId => MerklRootService.fetchFromCache(chainId)));
+        const merkleRoots = merkleRootsPromises
+            .filter(({ status }) => status === "fulfilled")
+            .map(x => x.value);
+        const rewards = RewardService.format(await RewardService.getByRecipient(query.address, merkleRoots.map(({ live }) => live), true, false, null, "UniswapV3"));
+        for (const reward of rewards) {
+            const rewardToken = reward.token;
+            for (const breakdown of reward.breakdowns) {
+                let poolAddress = breakdown.opportunity.explorerAddress;
+                if (!!poolAddress) {
+                    poolAddress = getAddress(poolAddress);
+                    res[poolAddress] = res[poolAddress] ?? {};
+                    if (!query.poolAddress || poolAddress === query.poolAddress) {
+                        const positionId = breakdown.reason.split("_")[1];
+                        if (!res[poolAddress][positionId])
+                            res[poolAddress][positionId] = [];
+                        const { opportunity, ...props } = breakdown;
+                        res[poolAddress][positionId].push({
+                            ...props,
+                            opportunity: OpportunityService.formatResponseBase(opportunity),
+                            rewardToken: rewardToken,
+                        });
+                    }
+                }
+            }
+        }
+        return res;
+    }
     static async getPoolsByChain(chainId) {
         const lastBlock = await providers[chainId].getBlockNumber();
         const logs = await safeFetchLogs(chainId, [PoolManagerInterface.getEventTopic("Initialize")], ["0xE8E23e97Fa135823143d6b9Cba9c699040D51F70"], 0, lastBlock);
@@ -77,7 +121,7 @@ export class UniswapV4Service {
         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 storedPools = await UniswapRepository.getStoredPools();
         const res = await Promise.all(UNIV4_CHAINIDS.map(async (chainId) => {
             chainId = chainId;
             const perChainIdRes = {};
@@ -212,7 +256,7 @@ export class UniswapV4Service {
         for (const chainId of UNIV4_CHAINIDS) {
             if (tableData.filter(p => p.chainId === chainId).length > 0) {
                 try {
-                    await UniswapV4Repository.createMany(tableData
+                    await UniswapRepository.createMany(tableData
                         .filter(point => point.chainId === chainId)
                         .map(pool => ({
                         fetchAtBlock: pool.fetchedAtBlock,

package/dist/src/routes/v1/prices.js

@@ -1,4 +1,4 @@
-import { PriceService } from "@/modules/v4/price";
+import { PriceService } from "@/modules/v4/price/price.service";
 import { t } from "elysia";
 export const response = t.Array(t.Object({ rate: t.Number(), token: t.String() }));
 export default (app) => app.get("/prices", async () => {

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

@@ -1,7 +1,7 @@
 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/uniswapV4";
+import { Bytes32Dto } from "@/modules/v4/uniswap/uniswap.model";
 import { UnsupportedNetwork } from "@/utils/error";
 export default (app) => app.group("/uniswapv4", router => router
     .get("/", async () => {

package/dist/src/scripts/fill-unknown-tokens.js

@@ -0,0 +1,58 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { log } from "@/utils/logger";
+import { apiDbClient } from "@db";
+const tokens = await apiDbClient.token.findMany({
+    select: {
+        address: true,
+        chainId: true,
+        name: true,
+        symbol: true,
+    },
+    where: {
+        symbol: "UNKNOWN",
+    },
+    orderBy: {
+        id: "asc",
+    },
+});
+log.info(`found ${tokens.length} tokens with UNKNOWN symbol`);
+for (const token of tokens) {
+    try {
+        const onchainData = await TokenService.fetchOnChain({
+            chainId: token.chainId,
+            address: token.address,
+        });
+        if (onchainData.name !== token.name) {
+            await apiDbClient.token.update({
+                where: {
+                    chainId_address: {
+                        address: token.address,
+                        chainId: token.chainId,
+                    },
+                },
+                data: {
+                    name: onchainData.name,
+                },
+            });
+            log.info(`updated name for ${token.address} on ${token.chainId} from ${token.name} to ${onchainData.name}`);
+        }
+        if (onchainData.symbol !== token.symbol) {
+            await apiDbClient.token.update({
+                where: {
+                    chainId_address: {
+                        address: token.address,
+                        chainId: token.chainId,
+                    },
+                },
+                data: {
+                    symbol: onchainData.symbol,
+                },
+            });
+            log.info(`updated name for ${token.address} on ${token.chainId} from ${token.name} to ${onchainData.name}`);
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+}
+process.exit(0);

package/dist/src/scripts/reparse-opportunities.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/{jobs → scripts}/reparse-opportunities.js

@@ -1,3 +1,4 @@
+// One-off script to modify opportunity metadata
 import { metadataBuilderFactory } from "@/engine/opportunityMetadata/factory";
 import { log } from "@/utils/logger";
 import { apiDbClient } from "@db";

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

@@ -1,5 +1,5 @@
 import { getTokensListWithCache } from "@/libs/getTokensList";
-import { PriceService as PriceSourceService } from "@/modules/v4/price";
+import { PriceService as PriceSourceService } from "@/modules/v4/price/price.service";
 import { PriceSourceMethod } from "@db/api";
 import { BN2Number, ChainId, Stable, registry } from "@sdk";
 import axios from "axios";

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

@@ -1,4 +1,4 @@
-import { PriceService } from "@/modules/v4/price";
+import { PriceService } from "@/modules/v4/price/price.service";
 import { PriceSourceMethod } from "@db/api";
 import { log } from "../../logger";
 import { getERC4626Price } from "./getERC4626";