@merkl/api 0.20.92 → 0.20.93

package/package.json

@@ -57,6 +57,7 @@
     "@notionhq/client": "^2.2.15",
     "@opentelemetry/auto-instrumentations-node": "^0.56.0",
     "@opentelemetry/instrumentation": "^0.57.1",
+    "@opentelemetry/instrumentation-redis-4": "^0.47.0",
     "@prisma/client": "6.3.1",
     "@prisma/instrumentation": "^6.3.1",
     "@sinclair/typebox": "^0.34.15",
@@ -109,5 +110,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "v0.20.92"
+  "version": "v0.20.93"
 }

package/dist/src/engine/dynamicData/implementations/Ambiant.js

@@ -1,232 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { AmbientAddresses, AmbientLens, BN2Number, ChainInteractionService, EAprBreakdownType, NETWORK_LABELS, YEAR, } from "@sdk";
-import moment from "moment";
-import { log } from "../../../utils/logger";
-import { Pricer } from "../../../utils/pricer";
-import { fetchAmbientPotentialPositions } from "../utils/fetchAmbientInfo";
-var AmbiantPositionType;
-(function (AmbiantPositionType) {
-    AmbiantPositionType["Concentrated"] = "concentrated";
-    AmbiantPositionType["Ambient"] = "ambient";
-    AmbiantPositionType["Knockout"] = "knockout";
-})(AmbiantPositionType || (AmbiantPositionType = {}));
-function encodeCall(chainId, holder) {
-    if (holder.positionType === AmbiantPositionType.Concentrated) {
-        return [
-            {
-                allowFailure: true,
-                callData: AmbientLens.encodeFunctionData("queryRangeTokens", [
-                    holder.owner,
-                    holder.base,
-                    holder.quote,
-                    holder.poolIdx,
-                    holder.lowerTick,
-                    holder.upperTick,
-                ]),
-                target: AmbientAddresses[chainId].CrocQuery,
-            },
-        ];
-    }
-    return [
-        {
-            allowFailure: true,
-            callData: AmbientLens.encodeFunctionData("queryAmbientTokens", [
-                holder.owner,
-                holder.base,
-                holder.quote,
-                holder.poolIdx,
-            ]),
-            target: AmbientAddresses[chainId].CrocQuery,
-        },
-    ];
-}
-async function decodeCall(result, holder) {
-    let amount0 = BigInt(0n);
-    let amount1 = BigInt(0n);
-    if (holder.positionType === AmbiantPositionType.Concentrated) {
-        const resTok = AmbientLens.decodeFunctionResult("queryRangeTokens", result);
-        amount0 = BigInt(resTok[1]);
-        amount1 = BigInt(resTok[2]);
-    }
-    if (holder.positionType === AmbiantPositionType.Ambient) {
-        const resTok = AmbientLens.decodeFunctionResult("queryAmbientTokens", result);
-        amount0 = BigInt(resTok[1]);
-        amount1 = BigInt(resTok[2]);
-    }
-    return { amount0, amount1 };
-}
-export class AmbiantDynamicData {
-    async build(chainId, campaigns) {
-        const dynamicData = [];
-        const pricer = await Pricer.load();
-        let calls = [];
-        /** Dedupe pools from campaigns to build pool list */
-        const poolList = [];
-        for (const campaign of campaigns ?? []) {
-            /** Loop through all campaigns to add pools */
-            if (!poolList?.map(p => p.mainParameter.toLowerCase()).includes(campaign.mainParameter.toLowerCase())) {
-                poolList.push({
-                    id: campaign.campaignParameters.poolId,
-                    mainParameter: campaign.mainParameter, // main parameter containes info of poolAddress + AMM (in case its a priority AMM)
-                    baseToken: campaign.campaignParameters.baseToken,
-                    quoteToken: campaign.campaignParameters.quoteToken,
-                    poolIdx: campaign.campaignParameters.poolIdx,
-                    potentialHolders: await fetchAmbientPotentialPositions(campaign.campaignParameters.poolId, campaign.computeChainId),
-                });
-            }
-        }
-        if (!!poolList) {
-            for (const pool of poolList) {
-                calls.push({
-                    allowFailure: true,
-                    callData: AmbientLens.encodeFunctionData("queryLiquidity", [pool.baseToken, pool.quoteToken, pool.poolIdx]),
-                    target: AmbientAddresses[chainId].CrocQuery,
-                }, {
-                    allowFailure: true,
-                    callData: AmbientLens.encodeFunctionData("queryCurveTick", [pool.baseToken, pool.quoteToken, pool.poolIdx]),
-                    target: AmbientAddresses[chainId].CrocQuery,
-                });
-                calls = calls.concat(...pool.potentialHolders.map(holder => encodeCall(chainId, holder)));
-            }
-            const result = await ChainInteractionService(chainId).fetchState(calls);
-            let i = 0;
-            if (!!poolList) {
-                for (const pool of poolList) {
-                    // This liquidity call gives the active liquidity on the pool. To get the total liquidity we would need to loop over all positions
-                    let poolTotalLiquidity;
-                    let activeTick;
-                    let poolBalanceToken0 = 0;
-                    let poolBalanceToken1 = 0;
-                    const d = campaigns?.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase())[0];
-                    const decimalsBaseToken = d.campaignParameters.decimalsBaseToken;
-                    const decimalsQuoteToken = d.campaignParameters.decimalsQuoteToken;
-                    const symbolBaseToken = d.campaignParameters.symbolBaseToken;
-                    const symbolQuoteToken = d.campaignParameters.symbolQuoteToken;
-                    const prevI = i;
-                    try {
-                        poolTotalLiquidity = BN2Number(AmbientLens.decodeFunctionResult("queryLiquidity", result[i++].returnData)[0]);
-                        activeTick = Number(AmbientLens.decodeFunctionResult("queryCurveTick", result[i++].returnData)[0]);
-                        for (let index = 0; index < pool.potentialHolders.length; index++) {
-                            // to verify
-                            if (calls.length === 0) {
-                                break;
-                            }
-                            const res = await decodeCall(result[i++].returnData, pool.potentialHolders[index]);
-                            poolBalanceToken0 += BN2Number(res.amount0, decimalsBaseToken);
-                            poolBalanceToken1 += BN2Number(res.amount1, decimalsQuoteToken);
-                        }
-                    }
-                    catch (e) {
-                        log.warn(`merklDynamic data - failed to decode state of pool ${pool.id} on ${NETWORK_LABELS[chainId]}`);
-                        i = prevI + 2 + pool.potentialHolders.length;
-                        continue;
-                    }
-                    const priceToken0 = (await pricer.get({
-                        address: d.campaignParameters.baseToken,
-                        chainId: chainId,
-                        symbol: symbolBaseToken,
-                    }));
-                    const priceToken1 = (await pricer.get({
-                        address: d.campaignParameters.quoteToken,
-                        chainId: chainId,
-                        symbol: symbolQuoteToken,
-                    }));
-                    /** Iterate over distributions to compute APRs */
-                    for (const campaign of campaigns.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase())) {
-                        const c = campaign;
-                        const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
-                        const startTimestamp = BN2Number(c.startTimestamp, 0);
-                        const endTimestamp = BN2Number(c.endTimestamp, 0);
-                        const isLive = moment().unix() >= startTimestamp && moment().unix() < endTimestamp;
-                        const totalWeight = BN2Number(c.campaignParameters.weightFees, 4) +
-                            BN2Number(c.campaignParameters.weightToken0, 4) +
-                            BN2Number(c.campaignParameters.weightToken1, 4);
-                        // Proportions in percentage
-                        const propFees = (BN2Number(c.campaignParameters.weightFees, 4) / totalWeight) * 100;
-                        const propToken0 = (BN2Number(c.campaignParameters.weightToken0, 4) / totalWeight) * 100;
-                        const propToken1 = (BN2Number(c.campaignParameters.weightToken1, 4) / totalWeight) * 100;
-                        let distributionMeanAPR = 0;
-                        const aprs = {};
-                        const aprBreakdowns = [];
-                        let priceRewardToken = 0;
-                        if (isLive && c.campaignParameters.symbolRewardToken !== "aglaMerkl") {
-                            // priceRewardToken = (await pricer.get({
-                            //   address: c.rewardToken,
-                            //   chainId: chainId,
-                            //   symbol: c.campaignParameters.symbolRewardToken,
-                            // })) as number;
-                            priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
-                            /** Yearly rewards in $ */
-                            const yearlyToken0Rewards = (propToken0 * priceRewardToken * amount * YEAR) / (endTimestamp - startTimestamp);
-                            const yearlyToken1Rewards = (propToken1 * priceRewardToken * amount * YEAR) / (endTimestamp - startTimestamp);
-                            const yearlyFeeRewards = (propFees * priceRewardToken * amount * YEAR) / (endTimestamp - startTimestamp);
-                            let poolAPRkey = "";
-                            const tvl = poolBalanceToken0 * priceToken0 + poolBalanceToken1 * priceToken1;
-                            distributionMeanAPR = (yearlyToken0Rewards + yearlyToken1Rewards + yearlyFeeRewards) / tvl;
-                            distributionMeanAPR = !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
-                            /**
-                             * @dev We cannot include a whitelisted distrib apr into the mean APR
-                             */
-                            if (c.campaignParameters.whitelist.length === 0) {
-                                poolAPRkey = "Average APR (rewards / pool TVL)";
-                                if (!aprs[poolAPRkey])
-                                    aprs[poolAPRkey] = 0;
-                                aprs[poolAPRkey] += distributionMeanAPR;
-                                // @Hugo wip: new way to structure aprBreakdowns
-                                aprBreakdowns.push({
-                                    address: pool.id,
-                                    value: distributionMeanAPR,
-                                    type: EAprBreakdownType.AVERAGE,
-                                    label: "Average APR (rewards / pool TVL)",
-                                });
-                                // APR per token
-                                poolAPRkey = `APR for holding ${c.campaignParameters.symbolBaseToken} in pool`;
-                                if (!aprs[poolAPRkey])
-                                    aprs[poolAPRkey] = 0;
-                                aprs[poolAPRkey] += yearlyToken0Rewards / (poolBalanceToken0 * priceToken0);
-                                // @Hugo wip: new way to structure aprBreakdowns
-                                aprBreakdowns.push({
-                                    address: pool.id,
-                                    value: yearlyToken0Rewards / (poolBalanceToken0 * priceToken0),
-                                    type: EAprBreakdownType.TOKEN1,
-                                    label: c.campaignParameters.symbolBaseToken,
-                                });
-                                poolAPRkey = `APR for holding  ${c.campaignParameters.symbolQuoteToken} in pool`;
-                                if (!aprs[poolAPRkey])
-                                    aprs[poolAPRkey] = 0;
-                                aprs[poolAPRkey] += yearlyToken1Rewards / (poolBalanceToken1 * priceToken1);
-                                // @Hugo wip: new way to structure aprBreakdowns
-                                aprBreakdowns.push({
-                                    address: pool.id,
-                                    value: yearlyToken1Rewards / (poolBalanceToken1 * priceToken1),
-                                    type: EAprBreakdownType.TOKEN2,
-                                    label: c.campaignParameters.symbolQuoteToken,
-                                });
-                            }
-                            else {
-                            }
-                        }
-                        const rewardTokens = await TokenService.findManyOrCreate([
-                            { chainId: campaign.chainId, address: campaign.rewardToken },
-                        ]);
-                        const rewardToken = rewardTokens[0];
-                        distributionMeanAPR = rewardToken.isPoint ? distributionMeanAPR / 365 / 100 : distributionMeanAPR;
-                        dynamicData.push({
-                            ...campaign,
-                            apr: distributionMeanAPR,
-                            aprs,
-                            forwarders: [],
-                            poolBalanceToken0,
-                            poolBalanceToken1,
-                            poolTotalLiquidity,
-                            tick: activeTick,
-                            priceRewardToken: priceRewardToken,
-                            tvl: poolBalanceToken0 * priceToken0 + poolBalanceToken1 * priceToken1,
-                        });
-                    }
-                }
-            }
-        }
-        return dynamicData;
-    }
-}

package/dist/src/engine/dynamicData/utils/fetchAmbientInfo.d.ts

@@ -1,12 +0,0 @@
-import { type MerklChainId } from "@sdk";
-export type AmbientHolderType = {
-    owner: string;
-    base: string;
-    quote: string;
-    poolIdx: number;
-    lowerTick: number;
-    upperTick: number;
-    positionType: string;
-};
-export declare const holdersQuery: string;
-export declare function fetchAmbientPotentialPositions(poolId: string, chainId: MerklChainId): Promise<AmbientHolderType[]>;

package/dist/src/engine/dynamicData/utils/fetchAmbientInfo.js

@@ -1,59 +0,0 @@
-import { subgraphAmbientEndpoints, withRetry } from "@sdk";
-import { gql, request } from "graphql-request";
-const BATCH_NUMBER = 1000;
-export const holdersQuery = gql `
-  query LiquidityChanges($poolId: String!, $minId: String!) {
-    liquidityChanges(
-      where: { pool_: { id: $poolId }, id_gt: $minId , positionType_not: "knockout"},
-      first: ${BATCH_NUMBER},
-      orderBy: pool__id
-    ) {
-      id  
-      user
-      positionType
-      bidTick
-      askTick
-      pool {
-        base
-        quote
-        poolIdx
-      }
-    }
-  }
-  `;
-export async function fetchAmbientPotentialPositions(poolId, chainId) {
-    let isFullyFetched = false;
-    let holders = [];
-    let minId = "";
-    while (!isFullyFetched) {
-        const data = await withRetry(request, [
-            subgraphAmbientEndpoints[chainId],
-            holdersQuery,
-            {
-                poolId: poolId,
-                minId: minId,
-            },
-        ]);
-        const fetchedHolders = data.liquidityChanges?.map(entry => {
-            return {
-                owner: entry.user,
-                base: entry.pool.base,
-                quote: entry.pool.quote,
-                poolIdx: Number(entry.pool.poolIdx),
-                lowerTick: Number(entry.bidTick),
-                upperTick: Number(entry.askTick),
-                positionType: entry.positionType,
-            };
-        });
-        if (fetchedHolders.length < BATCH_NUMBER) {
-            isFullyFetched = true;
-        }
-        else {
-            minId = data.liquidityChanges[fetchedHolders.length - 1].id;
-        }
-        holders = holders.concat(fetchedHolders);
-    }
-    // Only keep unique positions
-    holders = Array.from(new Set(holders.map(h => JSON.stringify(h)))).map(h => JSON.parse(h));
-    return holders;
-}