@merkl/api 0.18.14 → 0.19.0

package/dist/src/backgroundJobs/index.js

@@ -3,7 +3,6 @@ import { Redis } from "@/cache";
 import { redisClient } from "@/cache/redis";
 import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/libs/campaigns/utils/getEulerV2Vaults";
 import { getUniswapV4Pools } from "@/libs/campaigns/utils/getUniswapV4Pools";
-import { DungeonKeeperController } from "@/modules/v4/dungeonKeeper/dungeonKeeper.controller";
 import { log } from "@/utils/logger";
 import { engineDbClient } from "@db";
 import { swagger } from "@elysiajs/swagger";
@@ -33,9 +32,6 @@ new Elysia({
     .get("/uniswapv4Update", async () => {
     log.info("🔃 updating UniswapV4 pools...");
     await Redis.safeSet("UniswapV4Pools", await getUniswapV4Pools());
-})
-    .group("/v4", app => {
-    return app.use(DungeonKeeperController);
 })
     .onError(ctx => {
     console.error(ctx.error.message);

package/dist/src/jobs/set-dungeon-keeper.js

@@ -0,0 +1,82 @@
+import { Client } from "@notionhq/client";
+import { Client as DiscordClient, GatewayIntentBits } from "discord.js";
+import moment from "moment";
+const notion = new Client({ auth: process.env.NOTION_TOKEN });
+const discord = new DiscordClient({ intents: [GatewayIntentBits.GuildMembers] });
+const NOTION_EMAIL_TO_DISCORD_ID = {
+    picodes: "thepicodes",
+    hugo: "ugolxt",
+    alex: "wombomango",
+    nileco: ".nileco",
+    thibaudb: ".greedythib",
+    gnervo: "gs8nrv",
+    vincent: "vince_merkl",
+    hicham: "lamicham_93854",
+    pveyrat: "sogipec",
+    baptiste: "baptistg",
+    clement: "clmntngl",
+};
+async function fetchEntriesForDateWithTag(databaseId, date, tag) {
+    const response = await notion.databases.query({
+        database_id: databaseId,
+        filter: {
+            and: [
+                {
+                    property: "Date",
+                    date: {
+                        equals: date,
+                    },
+                },
+                {
+                    property: "Database",
+                    select: {
+                        equals: tag,
+                    },
+                },
+            ],
+        },
+    });
+    return response.results;
+}
+async function assignRole(notionId) {
+    const discordId = NOTION_EMAIL_TO_DISCORD_ID[notionId];
+    if (!discordId)
+        throw "Discord ID not found.";
+    await discord.login(process.env.DISCORD_TOKEN);
+    const guild = await discord.guilds.cache.get("862708408711643136");
+    if (!guild)
+        throw "Guild not found.";
+    const roles = await guild.roles.fetch();
+    const teamRole = roles.find(r => r.name === "Team");
+    const dkRole = roles.find(r => r.name === "Dungeon Keeper");
+    if (!teamRole || !dkRole)
+        throw "Roles not found.";
+    const users = await guild.members.fetch();
+    for (const [_id, dkUser] of users.filter(member => member.roles.cache.has(dkRole.id))) {
+        await dkUser.roles.remove(dkRole);
+    }
+    const user = users
+        .filter(member => member.roles.cache.has(teamRole.id))
+        .find(member => member.user.tag === discordId);
+    if (!user)
+        throw "User not found";
+    await user.roles.add(dkRole);
+    const channel = await discord.channels.fetch("1328383110957633630");
+    if (!channel)
+        throw "Channel not found";
+    if (channel.isSendable()) {
+        await channel.send(`Lucky you <@${user.id}>! You're the <@&${dkRole.id}> today!`);
+    }
+}
+async function main() {
+    const entries = await fetchEntriesForDateWithTag("8546f6a84641406bafb2358762281e81", moment().format("YYYY-MM-DD"), "Dungeon Keeper");
+    const user = entries?.[0];
+    if (!user) {
+        throw "No dk found for today";
+    }
+    const notionId = (user?.properties["Qui ?"]).people[0].person.email
+        .replace("@angle.money", "")
+        .replace("@merkl.xyz", "");
+    await assignRole(notionId);
+}
+await main();

package/dist/src/jobs/update-dynamic-data.d.ts

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

package/dist/src/jobs/update-uniswap-v4-pools.d.ts

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

package/dist/src/jobs/update-uniswap-v4-pools.js

@@ -0,0 +1,14 @@
+import { Redis } from "@/cache";
+import { UniswapV4Service } from "@/modules/v4/uniswapV4";
+async function main() {
+    try {
+        await Redis.safeSet("UniswapV4Pools", await UniswapV4Service.getPools());
+        process.exit(0);
+    }
+    catch (err) {
+        console.error("Failed to update Uniswap V4 pools cache.");
+        console.error(err);
+        process.exit(1);
+    }
+}
+await main();

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;
+    }
 }