@merkl/api 0.21.47 → 1.0.0

package/dist/src/modules/v4/liquidity/implementations/BadgerPositionFetcher.js

@@ -1,69 +0,0 @@
-import { CDPMANAGER_ADDRESS, SORTEDCDPS_ADDRESS } from "@/constants";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { BN2Number, Campaign, CdpManagerInterface, ChainInteractionService, ERC20Interface, SortedCdpsInterface, } from "@sdk";
-const campaignType = Campaign.BADGER;
-export class BadgerPositionFetcher {
-    fetchPositions = async (chainId, user, opportunities) => {
-        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
-        const calls = [];
-        calls.push({
-            allowFailure: false,
-            callData: CdpManagerInterface.encodeFunctionData("getSystemDebt"),
-            target: CDPMANAGER_ADDRESS,
-        });
-        for (const opportunity of opportunities) {
-            // Call per opportunity
-            const _campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
-            calls.push({
-                allowFailure: false,
-                callData: SortedCdpsInterface.encodeFunctionData("getCdpsOf", [user]),
-                target: SORTEDCDPS_ADDRESS,
-            });
-            for (const _token of opportunity.tokens) {
-                // Call per token
-            }
-        }
-        const res = await ChainInteractionService(chainId).fetchState(calls);
-        const result = [];
-        let i = 0;
-        const totalSupplyEBTC = BN2Number(CdpManagerInterface.decodeFunctionResult("getSystemDebt", res[i++].returnData)[0], 18);
-        for (const [index, opportunity] of opportunities.entries()) {
-            // Decoding per opportunity
-            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
-            let userSupply = 0;
-            const cdps = SortedCdpsInterface.decodeFunctionResult("getCdpsOf", res[i++].returnData)[0];
-            if (cdps.length !== 0) {
-                const secondCalls = cdps.map((cdp) => {
-                    return {
-                        allowFailure: false,
-                        callData: CdpManagerInterface.encodeFunctionData("Cdps", cdp),
-                        target: CDPMANAGER_ADDRESS,
-                    };
-                });
-                const secondRes = await ChainInteractionService(chainId).fetchState(secondCalls);
-                cdps.forEach((cdp, j) => {
-                    const cdpSupply = CdpManagerInterface.decodeFunctionResult("Cdps", secondRes[j].returnData)[0];
-                    userSupply += BN2Number(cdpSupply, campaign.campaignParameters.decimalsTargetToken);
-                });
-            }
-            for (const [subIndex, token] of opportunity.tokens.entries()) {
-                // Decoding per token
-                const balance = ERC20Interface.decodeFunctionResult("balanceOf", res[index + subIndex].returnData)[0].toString();
-                if (BigInt(balance) > 0n) {
-                    const position = {
-                        flags: {},
-                        opportunity,
-                        tokens: [
-                            {
-                                token,
-                                breakdown: [{ type: "balance", value: BN2Number(balance, token.decimals) }],
-                            },
-                        ],
-                    };
-                    result.push(position);
-                }
-            }
-        }
-        return result;
-    };
-}

package/dist/src/modules/v4/liquidity/implementations/ClammPositionFetcher.js

@@ -1,61 +0,0 @@
-import { getClammUserPositions } from "@/libs/positions/clamm";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { Campaign } from "@sdk";
-const campaignType = Campaign.CLAMM;
-export class ClammPositionFetcher {
-    fetchPositions = async (chainId, user, opportunities) => {
-        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
-        // AMM => pool address => pool data
-        const poolsByAmm = {};
-        for (const opportunity of opportunities) {
-            // Call per opportunity
-            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
-            if (!poolsByAmm[campaign.campaignParameters.amm]) {
-                poolsByAmm[campaign.campaignParameters.amm] = {};
-            }
-            if (!poolsByAmm[campaign.campaignParameters.amm][campaign.campaignParameters.poolAddress]) {
-                poolsByAmm[campaign.campaignParameters.amm][campaign.campaignParameters.poolAddress] = {
-                    token0: campaign.campaignParameters.token0,
-                    token1: campaign.campaignParameters.token1,
-                    symbolToken0: campaign.campaignParameters.symbolToken0,
-                    symbolToken1: campaign.campaignParameters.symbolToken1,
-                    decimalsToken0: campaign.campaignParameters.decimalsToken0,
-                    decimalsToken1: campaign.campaignParameters.decimalsToken1,
-                    mainParameter: campaign.mainParameter,
-                    forwarders: {},
-                };
-            }
-        }
-        const clammPositions = await getClammUserPositions(user, chainId, poolsByAmm, false);
-        const result = [];
-        for (const opportunity of opportunities) {
-            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
-            const clammPosition = clammPositions[`2_${campaign.campaignParameters.poolAddress}`];
-            const poolData = poolsByAmm[campaign.campaignParameters.amm][campaign.campaignParameters.poolAddress];
-            if (!!clammPosition) {
-                const position = {
-                    flags: {},
-                    opportunity,
-                    tokens: [
-                        {
-                            token: opportunity.tokens.filter(t => t.address === poolData.token0)?.[0],
-                            breakdown: [
-                                { type: "balance", value: clammPosition.userBalanceToken0 },
-                                { type: "liquidity", value: clammPosition.userInRangeLiquidity },
-                            ],
-                        },
-                        {
-                            token: opportunity.tokens.filter(t => t.address === poolData.token1)?.[0],
-                            breakdown: [
-                                { type: "balance", value: clammPosition.userBalanceToken1 },
-                                { type: "liquidity", value: clammPosition.userInRangeLiquidity },
-                            ],
-                        },
-                    ],
-                };
-                result.push(position);
-            }
-        }
-        return result;
-    };
-}

package/dist/src/modules/v4/liquidity/implementations/DolomitePositionFetcher.js

@@ -1,45 +0,0 @@
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { Campaign } from "@sdk";
-import { utils } from "ethers";
-import { LiquidityRepository } from "../liquidity.repository";
-const campaignType = Campaign.DOLOMITE;
-export class DolomitePositionFetcher {
-    fetchPositions = async (chainId, user, opportunities) => {
-        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
-        const dolomitePositions = await LiquidityRepository.findManyDolomitePositions(chainId, user);
-        // Generic calls
-        for (const opportunity of opportunities) {
-            // Call per opportunity
-            const _campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
-            for (const _token of opportunity.tokens) {
-                // Call per token
-            }
-        }
-        const result = [];
-        // Decoding Generic calls
-        for (const [_index, opportunity] of opportunities.entries()) {
-            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
-            // Decoding per opportunity
-            const positionIndex = dolomitePositions.findIndex(y => utils.getAddress(y.token.id) === campaign.campaignParameters.targetToken);
-            const position = positionIndex >= 0 ? dolomitePositions[positionIndex] : undefined;
-            if (!position)
-                continue;
-            const borrowBalance = Number.parseFloat(position.token.borrowLiquidity);
-            const supplyBalance = Number.parseFloat(position.token.supplyLiquidity);
-            result.push({
-                flags: {},
-                opportunity,
-                tokens: [
-                    {
-                        token: opportunity.tokens.find(t => utils.getAddress(t.address) === campaign.campaignParameters.targetToken),
-                        breakdown: [
-                            { type: "borrowed", value: borrowBalance },
-                            { type: "supplied", value: supplyBalance },
-                        ],
-                    },
-                ],
-            });
-        }
-        return result;
-    };
-}

package/dist/src/modules/v4/liquidity/implementations/ERC20PositionFetcher.js

@@ -1,47 +0,0 @@
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { BN2Number, Campaign, ChainInteractionService, ERC20Interface } from "@sdk";
-const campaignType = Campaign.ERC20;
-export class ERC20PositionFetcher {
-    fetchPositions = async (chainId, user, opportunities) => {
-        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
-        const calls = [];
-        // Generic calls
-        for (const opportunity of opportunities) {
-            // Call per opportunity
-            const _campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
-            for (const token of opportunity.tokens) {
-                // Call per token
-                calls.push({
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
-                    target: token.address,
-                });
-            }
-        }
-        const res = await ChainInteractionService(chainId).fetchState(calls);
-        const result = [];
-        // Decoding Generic calls
-        for (const [index, opportunity] of opportunities.entries()) {
-            // Decoding per opportunity
-            const _campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
-            for (const [subIndex, token] of opportunity.tokens.entries()) {
-                // Decoding per token
-                const balance = ERC20Interface.decodeFunctionResult("balanceOf", res[index + subIndex].returnData)[0].toString();
-                if (BigInt(balance) > 0n) {
-                    const position = {
-                        flags: {},
-                        opportunity,
-                        tokens: [
-                            {
-                                token,
-                                breakdown: [{ type: "balance", value: BN2Number(balance, token.decimals) }],
-                            },
-                        ],
-                    };
-                    result.push(position);
-                }
-            }
-        }
-        return result;
-    };
-}

package/dist/src/modules/v4/liquidity/implementations/EulerPositionFetcher.js

@@ -1,40 +0,0 @@
-import { BN2Number, Campaign, ChainInteractionService, ERC20Interface } from "@sdk";
-const campaignType = Campaign.EULER;
-export class EulerPositionFetcher {
-    fetchPositions = async (chainId, user, opportunities) => {
-        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
-        const calls = [];
-        for (const opportunity of opportunities) {
-            // Call per opportunity
-            for (const token of opportunity.tokens) {
-                calls.push({
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
-                    target: token.address,
-                });
-            }
-        }
-        const res = await ChainInteractionService(chainId).fetchState(calls);
-        const result = [];
-        for (const [index, opportunity] of opportunities.entries()) {
-            // Decoding calls per opportunity
-            for (const [subIndex, token] of opportunity.tokens.entries()) {
-                const balance = ERC20Interface.decodeFunctionResult("balanceOf", res[index + subIndex].returnData)[0].toString();
-                if (BigInt(balance) > 0n) {
-                    const position = {
-                        flags: {},
-                        opportunity,
-                        tokens: [
-                            {
-                                token,
-                                breakdown: [{ type: "balance", value: BN2Number(balance, token.decimals) }],
-                            },
-                        ],
-                    };
-                    result.push(position);
-                }
-            }
-        }
-        return result;
-    };
-}

package/dist/src/modules/v4/liquidity/liquidity.controller.js

@@ -1,16 +0,0 @@
-import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
-import { Elysia } from "elysia";
-import { PositionsInputDto } from "./liquidity.model";
-import { LiquidityService } from "./liquidity.service";
-// ─── Positions Controller ──────────────────────────────────────────────
-export const LiquidityController = new Elysia({ prefix: "/liquidity", detail: { tags: ["Positions"], hide: true } })
-    // ─── Get User Positions on a Chain ───────────────────────────────────
-    .get("/", async ({ query }) => {
-    return await LiquidityService.fetchPositions(query);
-}, {
-    query: PositionsInputDto,
-    beforeHandle: ({ query }) => {
-        throwOnUnsupportedChainId(query.chainId);
-        query.address = throwOnInvalidRequiredAddress(query.address);
-    },
-});

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

@@ -1,5 +0,0 @@
-import { t } from "elysia";
-export const PositionsInputDto = t.Object({
-    chainId: t.Numeric(),
-    address: t.String(),
-});

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

@@ -1,6 +0,0 @@
-import axios from "axios";
-export class LiquidityRepository {
-    static async findManyDolomitePositions(chainId, user) {
-        return (await axios.get(`https://api.dolomite.io/balances/${chainId}/users/${user}`)).data.Result;
-    }
-}

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

@@ -1,34 +0,0 @@
-import { MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT } from "@/constants";
-import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
-import { Campaign, withTimeout } from "@sdk";
-import { AjnaPositionFetcher } from "./implementations/AjnaPositionFetcher";
-import { BadgerPositionFetcher } from "./implementations/BadgerPositionFetcher";
-import { ClammPositionFetcher } from "./implementations/ClammPositionFetcher";
-import { DolomitePositionFetcher } from "./implementations/DolomitePositionFetcher";
-import { ERC20PositionFetcher } from "./implementations/ERC20PositionFetcher";
-import { EulerPositionFetcher } from "./implementations/EulerPositionFetcher";
-export class LiquidityService {
-    static #fetchers = {
-        [Campaign.ERC20]: new ERC20PositionFetcher(),
-        [Campaign.EULER]: new EulerPositionFetcher(),
-        [Campaign.AJNA]: new AjnaPositionFetcher(),
-        [Campaign.BADGER]: new BadgerPositionFetcher(),
-        [Campaign.CLAMM]: new ClammPositionFetcher(),
-        [Campaign.DOLOMITE]: new DolomitePositionFetcher(),
-    };
-    static async fetchPositions(query) {
-        const opportunities = await OpportunityService.findLiveWithCampaigns(query.chainId, 1);
-        const promises = [];
-        for (const campaignType of Object.keys(Campaign)) {
-            const fetcher = LiquidityService.#fetchers[Number.parseInt(campaignType)];
-            if (fetcher) {
-                promises.push(withTimeout(fetcher.fetchPositions(query.chainId, query.address, opportunities.filter(o => !!o)), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-            }
-        }
-        const settledPromises = await Promise.allSettled(promises);
-        for (const errors of settledPromises.filter(p => p.status === "rejected")) {
-            console.error(errors.reason);
-        }
-        return settledPromises.filter(p => p.status === "fulfilled").flatMap(p => p.value);
-    }
-}

package/dist/src/modules/v4/merklRoot/merklRoot.controller.js

@@ -1,31 +0,0 @@
-import { AuthorizationHeadersDto, EngineGuard } from "@/guards/Engine.guard";
-import { throwOnUnsupportedChainId } from "@/utils/throw";
-import Elysia from "elysia";
-import { CreateRootDto, RootByTimestampsDto } from "./merklRoot.model";
-import { MerklRootService } from "./merklRoot.service";
-// ─── Merkl Roots Controller ─────────────────────────────────────────────
-export const MerklRootController = new Elysia({ prefix: "/roots", detail: { tags: ["Roots"] } })
-    // ─── Get Merkl Root By Timestamp ─────────────────────────────────────
-    .get("/", async ({ query }) => await MerklRootService.rootForTimestamp(query), {
-    query: RootByTimestampsDto,
-    beforeHandle: async ({ query }) => {
-        throwOnUnsupportedChainId(query.chainId);
-    },
-    detail: {
-        description: "Returns the last merkl roots recorded before the provided timestamps",
-    },
-})
-    // ─── Get all live Merkl Roots ─────────────────────────────────────────
-    .get("/live", async () => await MerklRootService.fetchAll())
-    // ─── Create a Merkl Root Entry ────────────────────────────────────────
-    .post("/engine", async ({ body }) => {
-    return await MerklRootService.create(body);
-}, {
-    headers: AuthorizationHeadersDto,
-    body: CreateRootDto,
-    beforeHandle: ({ headers, body }) => {
-        EngineGuard({ headers });
-        throwOnUnsupportedChainId(body.chainId);
-    },
-    detail: { hide: true },
-});

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

@@ -1,12 +0,0 @@
-import { t } from "elysia";
-export const RootByTimestampsDto = t.Object({
-    chainId: t.Numeric(),
-    fromTimestamp: t.String(),
-    toTimestamp: t.String(),
-});
-export const CreateRootDto = t.Object({
-    chainId: t.Numeric(),
-    root: t.String(),
-    timestamp: t.Numeric(),
-    epoch: t.Numeric(),
-});

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

@@ -1,56 +0,0 @@
-import { log } from "@/utils/logger";
-import { apiDbClient } from "@db";
-import { DistributorService, NETWORK_LABELS, withTimeout } from "@sdk";
-export class MerklRootRepository {
-    static async firstRoot(chainId) {
-        return await apiDbClient.merklRoot.findFirst({
-            where: { chainId },
-            orderBy: { timestamp: "desc" },
-        });
-    }
-    static async rootForTimestamp(x) {
-        const res = await apiDbClient.$transaction([
-            apiDbClient.merklRoot.findFirst({
-                where: { chainId: x.chainId, timestamp: { lte: BigInt(x.toTimestamp) } },
-                orderBy: { timestamp: "desc" },
-            }),
-            apiDbClient.merklRoot.findFirst({
-                where: { chainId: x.chainId, timestamp: { lte: BigInt(x.fromTimestamp) } },
-                orderBy: { timestamp: "desc" },
-            }),
-        ]);
-        if (!res[0] || !res[1]) {
-            throw new Error("Root not found");
-        }
-        return [res[0], res[1]];
-    }
-    static async fetch(chainId) {
-        const RPC_CALL_TIMEOUT = 10_000;
-        try {
-            // Try fetching the data using a RPC
-            const { live, tree, lastTree, endOfDisputePeriod, disputer } = await withTimeout(DistributorService(chainId).fetchUpdateData(), RPC_CALL_TIMEOUT);
-            return { live, tree, lastTree, endOfDisputePeriod, disputer };
-        }
-        catch (e) {
-            let errorMessage = null;
-            // If the error is a timeout, log a warning and return a void object
-            if (e.message === `Timed out after ${RPC_CALL_TIMEOUT}ms`) {
-                errorMessage = `fetching Merkle Root for chain ${NETWORK_LABELS[chainId]} timed out`;
-            }
-            // If the error is a rpc failure, log a warning and return a void object
-            if (e.message === "EVMDistributorService: fetchUpdateData multicall failed") {
-                errorMessage = `fetching Merkle Root for chain ${NETWORK_LABELS[chainId]} multicall failed`;
-            }
-            if (errorMessage) {
-                log.warn(errorMessage);
-                return {}; // Return an empty object to indicate failure and prevent further trials of fetching this
-            }
-            throw e;
-        }
-    }
-    static async create(x) {
-        return await apiDbClient.merklRoot.create({
-            data: x,
-        });
-    }
-}

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

@@ -1,48 +0,0 @@
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { log } from "@/utils/logger";
-import { NETWORK_LABELS } from "@sdk";
-import { TTLPresets } from "../cache/cache.model";
-import { ChainService } from "../chain/chain.service";
-import { MerklRootRepository } from "./merklRoot.repository";
-export class MerklRootService {
-    static async firstRoot(chainId) {
-        return await MerklRootRepository.firstRoot(chainId);
-    }
-    static async rootForTimestamp(x) {
-        return await MerklRootRepository.rootForTimestamp(x);
-    }
-    static async fetchFromCache(chainId) {
-        let data = await CacheService.get(MerklRootRepository.fetch, [chainId]);
-        // If the data is null, it means the cache is empty
-        if (data === null) {
-            log.info(`cache is empty for Merkle Root on ${NETWORK_LABELS[chainId]}, using rpc...`);
-            data = await CacheService.wrap(TTLPresets.MIN_1, MerklRootRepository.fetch, chainId);
-        }
-        if (data.lastTree === undefined)
-            throw `fetching Merkle Root on ${NETWORK_LABELS[chainId]} timed out`;
-        return data;
-    }
-    /**
-     * Fetch all roots for the provided chains
-     * @param chainIds to fetch roots for
-     * @returns record of chains to object with live and last tree roots
-     */
-    static async fetchAll(chainIds) {
-        return await CacheService.wrap(TTLPresets.MIN_1, async () => {
-            let ids = chainIds ?? (await ChainService.findManyIds());
-            /** Fetch current Merkle Roots */
-            const merkleRootsPromises = await Promise.allSettled(ids.map(chainId => MerklRootService.fetchFromCache(chainId)));
-            /** Filter out unsuccessful chainIds */
-            ids = ids.filter((_, index) => merkleRootsPromises[index].status === "fulfilled");
-            return merkleRootsPromises
-                .filter(({ status }) => status === "fulfilled")
-                .reduce((acc, promise, index) => {
-                acc[ids[index]] = promise.value;
-                return acc;
-            }, {});
-        });
-    }
-    static async create(x) {
-        return await MerklRootRepository.create(x);
-    }
-}